Benibenj/registerContextKeyHandler

src/vs/workbench/browser/parts/editor/editorParts.ts

@@ -4,9 +4,9 @@
  *--------------------------------------------------------------------------------------------*/
 
 import { localize } from 'vs/nls';
-import { EditorGroupLayout, GroupDirection, GroupLocation, GroupOrientation, GroupsArrangement, GroupsOrder, IAuxiliaryEditorPart, IAuxiliaryEditorPartCreateEvent, IEditorDropTargetDelegate, IEditorGroupsService, IEditorSideGroup, IEditorWorkingSet, IFindGroupScope, IMergeGroupOptions } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { EditorGroupLayout, GroupDirection, GroupLocation, GroupOrientation, GroupsArrangement, GroupsOrder, IAuxiliaryEditorPart, IAuxiliaryEditorPartCreateEvent, IEditorGroupContextKeyProvider, IEditorDropTargetDelegate, IEditorGroupsService, IEditorSideGroup, IEditorWorkingSet, IFindGroupScope, IMergeGroupOptions } from 'vs/workbench/services/editor/common/editorGroupsService';
 import { Emitter } from 'vs/base/common/event';
-import { DisposableStore, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
+import { DisposableMap, DisposableStore, IDisposable, toDisposable } from 'vs/base/common/lifecycle';
 import { GroupIdentifier } from 'vs/workbench/common/editor';
 import { EditorPart, IEditorPartUIState, MainEditorPart } from 'vs/workbench/browser/parts/editor/editorPart';
 import { IEditorGroupView, IEditorPartsView } from 'vs/workbench/browser/parts/editor/editor';
@@ -127,9 +127,13 @@ export class EditorParts extends MultiWindowParts<EditorPart> implements IEditor
 			this.updateGlobalContextKeys();
 			this._onDidActiveGroupChange.fire(group);
 		}));
-		disposables.add(part.onDidAddGroup(group => this._onDidAddGroup.fire(group)));
+		disposables.add(part.onDidAddGroup(group => {
+			this.registerRunGroupContextKeyProviders(group);
+			this._onDidAddGroup.fire(group);
+		}));
 		disposables.add(part.onDidRemoveGroup(group => {
 			this.removeGroupScopedContextKeys(group);
+			this.unregisterRunGroupContextKeyProviders(group);
 			this._onDidRemoveGroup.fire(group);
 		}));
 		disposables.add(part.onDidMoveGroup(group => this._onDidMoveGroup.fire(group)));
@@ -696,10 +700,75 @@ export class EditorParts extends MultiWindowParts<EditorPart> implements IEditor
 	}
 
 	private removeGroupScopedContextKeys(group: IEditorGroupView): void {
-		const groupScopedContextKeys = this.scopedContextKeys.get(group.id);
-		if (groupScopedContextKeys) {
-			this.scopedContextKeys.delete(group.id);
+		this.scopedContextKeys.delete(group.id);
+		this.registeredContextKeys.delete(group.id);
+	}
+
+	private readonly contextKeyProviders = new Map<string, IEditorGroupContextKeyProvider<ContextKeyValue>>();
+	private readonly registeredContextKeys = new Map<GroupIdentifier, Map<string, IContextKey>>();
+
+	registerContextKeyProvider<T extends ContextKeyValue>(provider: IEditorGroupContextKeyProvider<T>): IDisposable {
+		if (this.contextKeyProviders.has(provider.contextKey.key) || this.globalContextKeys.has(provider.contextKey.key)) {
+			throw new Error(`A context key provider for key ${provider.contextKey.key} already exists.`);
 		}
+
+		this.contextKeyProviders.set(provider.contextKey.key, provider);
+
+		const setContextKeyForGroups = () => {
+			for (const group of this.groups) {
+				this.runRegisteredContextKeyProvider(group, provider);
+			}
+		};
+
+		// Run initially and on change
+		setContextKeyForGroups();
+		const onDidChange = provider.onDidChange?.(() => setContextKeyForGroups());
+
+		return toDisposable(() => {
+			onDidChange?.dispose();
+			this.contextKeyProviders.delete(provider.contextKey.key);
+			this.globalContextKeys.delete(provider.contextKey.key);
+			this.scopedContextKeys.forEach(scopedContextKeys => scopedContextKeys.delete(provider.contextKey.key));
+			this.registeredContextKeys.forEach(registeredContextKeys => registeredContextKeys.delete(provider.contextKey.key));
+		});
+	}
+
+	private groupContextKeyProvidersRunners = this._register(new DisposableMap<GroupIdentifier, IDisposable>());
+	private registerRunGroupContextKeyProviders(group: IEditorGroupView): void {
+		if (this.groupContextKeyProvidersRunners.has(group.id)) {
+			throw new Error(`A context key provider runner for group ${group.id} already exists.`);
+		}
+
+		// Run the context key providers when the active editor changes
+		const disposable = group.onDidActiveEditorChange(() => {
+			for (const contextKeyProvider of this.contextKeyProviders.values()) {
+				this.runRegisteredContextKeyProvider(group, contextKeyProvider);
+			}
+		});
+		this.groupContextKeyProvidersRunners.set(group.id, disposable);
+	}
+
+	private unregisterRunGroupContextKeyProviders(group: IEditorGroupView): void {
+		this.groupContextKeyProvidersRunners.deleteAndDispose(group.id);
+	}
+
+	private runRegisteredContextKeyProvider<T extends ContextKeyValue>(group: IEditorGroupView, provider: IEditorGroupContextKeyProvider<T>): void {
+		// Get the group scoped context keys for the provider
+		// If the providers context key has not yet been bound to the group, do so now
+		let groupRegisteredContextKeys = this.registeredContextKeys.get(group.id);
+		if (!groupRegisteredContextKeys) {
+			groupRegisteredContextKeys = new Map<string, IContextKey>();
+			this.scopedContextKeys.set(group.id, groupRegisteredContextKeys);
+		}
+
+		let scopedRegisteredContextKey = groupRegisteredContextKeys.get(provider.contextKey.key);
+		if (!scopedRegisteredContextKey) {
+			scopedRegisteredContextKey = this.bind(provider.contextKey, group);
+			groupRegisteredContextKeys.set(provider.contextKey.key, scopedRegisteredContextKey);
+		}
+
+		// Set the context key value for the group context
+		scopedRegisteredContextKey.set(provider.getGroupContextKeyValue(group));
 	}
 
 	//#endregion

src/vs/workbench/contrib/scm/browser/activity.ts

@@ -6,7 +6,7 @@
 import { localize } from 'vs/nls';
 import { basename } from 'vs/base/common/resources';
 import { IDisposable, dispose, Disposable, DisposableStore, combinedDisposable, MutableDisposable } from 'vs/base/common/lifecycle';
-import { Event } from 'vs/base/common/event';
+import { Emitter, Event } from 'vs/base/common/event';
 import { VIEW_PANE_ID, ISCMService, ISCMRepository, ISCMViewService } from 'vs/workbench/contrib/scm/common/scm';
 import { IActivityService, NumberBadge } from 'vs/workbench/services/activity/common/activity';
 import { IWorkbenchContribution } from 'vs/workbench/common/contributions';
@@ -19,6 +19,8 @@ import { IUriIdentityService } from 'vs/platform/uriIdentity/common/uriIdentity'
 import { Schemas } from 'vs/base/common/network';
 import { Iterable } from 'vs/base/common/iterator';
 import { ITitleService } from 'vs/workbench/services/title/browser/titleService';
+import { IEditorGroupContextKeyProvider, IEditorGroupsService } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { EditorInput } from 'vs/workbench/common/editor/editorInput';
 
 function getCount(repository: ISCMRepository): number {
 	if (typeof repository.provider.count === 'number') {
@@ -291,74 +293,98 @@ export class SCMActiveRepositoryContextKeyController implements IWorkbenchContri
 
 export class SCMActiveResourceContextKeyController implements IWorkbenchContribution {
 
-	private activeResourceHasChangesContextKey: IContextKey<boolean>;
-	private activeResourceRepositoryContextKey: IContextKey<string | undefined>;
 	private readonly disposables = new DisposableStore();
 	private repositoryDisposables = new Set<IDisposable>();
+	private onDidRepositoryChange = new Emitter<void>();
 
 	constructor(
-		@IContextKeyService contextKeyService: IContextKeyService,
-		@IEditorService private readonly editorService: IEditorService,
+		@IEditorGroupsService editorGroupsService: IEditorGroupsService,
 		@ISCMService private readonly scmService: ISCMService,
 		@IUriIdentityService private readonly uriIdentityService: IUriIdentityService
 	) {
-		this.activeResourceHasChangesContextKey = contextKeyService.createKey('scmActiveResourceHasChanges', false);
-		this.activeResourceRepositoryContextKey = contextKeyService.createKey('scmActiveResourceRepository', undefined);
+		const activeResourceHasChangesContextKey = new RawContextKey<boolean>('scmActiveResourceHasChanges', false, localize('scmActiveResourceHasChanges', "Whether the active resource has changes"));
+		const activeResourceRepositoryContextKey = new RawContextKey<string | undefined>('scmActiveResourceRepository', undefined, localize('scmActiveResourceRepository', "The active resource's repository"));
 
 		this.scmService.onDidAddRepository(this.onDidAddRepository, this, this.disposables);
 
 		for (const repository of this.scmService.repositories) {
 			this.onDidAddRepository(repository);
 		}
 
-		editorService.onDidActiveEditorChange(this.updateContextKey, this, this.disposables);
+		// Create context key providers which will update the context keys based on each groups active editor
+		const hasChangesContextKeyProvider: IEditorGroupContextKeyProvider<boolean> = {
+			contextKey: activeResourceHasChangesContextKey,
+			getGroupContextKeyValue: (group) => this.getEditorHasChanges(group.activeEditor),
+			onDidChange: this.onDidRepositoryChange.event
+		};
+
+		const repositoryContextKeyProvider: IEditorGroupContextKeyProvider<string | undefined> = {
+			contextKey: activeResourceRepositoryContextKey,
+			getGroupContextKeyValue: (group) => this.getEditorRepositoryId(group.activeEditor),
+			onDidChange: this.onDidRepositoryChange.event
+		};
+
+		this.disposables.add(editorGroupsService.registerContextKeyProvider(hasChangesContextKeyProvider));
+		this.disposables.add(editorGroupsService.registerContextKeyProvider(repositoryContextKeyProvider));
 	}
 
 	private onDidAddRepository(repository: ISCMRepository): void {
 		const onDidChange = Event.any(repository.provider.onDidChange, repository.provider.onDidChangeResources);
-		const changeDisposable = onDidChange(() => this.updateContextKey());
+		const changeDisposable = onDidChange(() => {
+			this.onDidRepositoryChange.fire();
+		});
 
 		const onDidRemove = Event.filter(this.scmService.onDidRemoveRepository, e => e === repository);
 		const removeDisposable = onDidRemove(() => {
 			disposable.dispose();
 			this.repositoryDisposables.delete(disposable);
-			this.updateContextKey();
+			this.onDidRepositoryChange.fire();
 		});
 
 		const disposable = combinedDisposable(changeDisposable, removeDisposable);
 		this.repositoryDisposables.add(disposable);
 	}
 
-	private updateContextKey(): void {
-		const activeResource = EditorResourceAccessor.getOriginalUri(this.editorService.activeEditor);
+	private getEditorRepositoryId(activeEditor: EditorInput | null): string | undefined {
+		const activeResource = EditorResourceAccessor.getOriginalUri(activeEditor);
 
 		if (activeResource?.scheme === Schemas.file || activeResource?.scheme === Schemas.vscodeRemote) {
 			const activeResourceRepository = Iterable.find(
 				this.scmService.repositories,
 				r => Boolean(r.provider.rootUri && this.uriIdentityService.extUri.isEqualOrParent(activeResource, r.provider.rootUri))
 			);
 
-			this.activeResourceRepositoryContextKey.set(activeResourceRepository?.id);
+			return activeResourceRepository?.id;
+		}
+
+		return undefined;
+	}
+
+	private getEditorHasChanges(activeEditor: EditorInput | null): boolean {
+		const activeResource = EditorResourceAccessor.getOriginalUri(activeEditor);
+
+		if (activeResource?.scheme === Schemas.file || activeResource?.scheme === Schemas.vscodeRemote) {
+			const activeResourceRepository = Iterable.find(
+				this.scmService.repositories,
+				r => Boolean(r.provider.rootUri && this.uriIdentityService.extUri.isEqualOrParent(activeResource, r.provider.rootUri))
+			);
 
 			for (const resourceGroup of activeResourceRepository?.provider.groups ?? []) {
 				if (resourceGroup.resources
 					.some(scmResource =>
 						this.uriIdentityService.extUri.isEqual(activeResource, scmResource.sourceUri))) {
-					this.activeResourceHasChangesContextKey.set(true);
-					return;
+					return true;
 				}
 			}
-
-			this.activeResourceHasChangesContextKey.set(false);
-		} else {
-			this.activeResourceHasChangesContextKey.set(false);
-			this.activeResourceRepositoryContextKey.set(undefined);
 		}
+
+		return false;
 	}
 
 	dispose(): void {
 		this.disposables.dispose();
 		dispose(this.repositoryDisposables.values());
 		this.repositoryDisposables.clear();
+		this.onDidRepositoryChange.dispose();
 	}
 }

src/vs/workbench/services/editor/common/editorGroupsService.ts

@@ -11,7 +11,7 @@ import { IEditorOptions } from 'vs/platform/editor/common/editor';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IDimension } from 'vs/editor/common/core/dimension';
 import { DisposableStore, IDisposable } from 'vs/base/common/lifecycle';
-import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
+import { ContextKeyValue, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey';
 import { URI } from 'vs/base/common/uri';
 import { IGroupModelChangeEvent } from 'vs/workbench/common/editor/editorGroupModel';
 import { IRectangle } from 'vs/platform/window/common/window';
@@ -491,6 +491,23 @@ export interface IEditorWorkingSet {
 	readonly name: string;
 }
 
+export interface IEditorGroupContextKeyProvider<T extends ContextKeyValue> {
+	/**
+	 * The context key that needs to be set for each editor group context and the global context.
+	 */
+	readonly contextKey: RawContextKey<T>;
+
+	/**
+	 * Retrieves the context key value for the given editor group.
+	 */
+	readonly getGroupContextKeyValue: (group: IEditorGroup) => T;
+
+	/**
+	 * An event that is fired when there was a change leading to the context key value to be re-evaluated.
+	 */
+	readonly onDidChange?: Event<void>;
+}
+
 /**
  * The main service to interact with editor groups across all opened editor parts.
  */
@@ -561,6 +578,14 @@ export interface IEditorGroupsService extends IEditorGroupsContainer {
 	 * Deletes a working set.
 	 */
 	deleteWorkingSet(workingSet: IEditorWorkingSet): void;
+
+	/**
+	 * Registers a context key provider. This provider sets a context key for each scoped editor group context and the global context.
+	 *
+	 * @param provider - The context key provider to be registered.
+	 * @returns - A disposable object to unregister the provider.
+	 */
+	registerContextKeyProvider<T extends ContextKeyValue>(provider: IEditorGroupContextKeyProvider<T>): IDisposable;
 }
 
 export const enum OpenEditorContext {

src/vs/workbench/test/browser/workbenchTestServices.ts

@@ -41,7 +41,7 @@ import { TestThemeService } from 'vs/platform/theme/test/common/testThemeService
 import { ITextResourceConfigurationService, ITextResourcePropertiesService } from 'vs/editor/common/services/textResourceConfiguration';
 import { IPosition, Position as EditorPosition } from 'vs/editor/common/core/position';
 import { IMenuService, MenuId, IMenu, IMenuChangeEvent } from 'vs/platform/actions/common/actions';
-import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
+import { ContextKeyValue, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { MockContextKeyService, MockKeybindingService } from 'vs/platform/keybinding/test/common/mockKeybindingService';
 import { ITextBufferFactory, DefaultEndOfLine, EndOfLinePreference, ITextSnapshot } from 'vs/editor/common/model';
 import { Range } from 'vs/editor/common/core/range';
@@ -52,7 +52,7 @@ import { IExtensionService } from 'vs/workbench/services/extensions/common/exten
 import { IKeybindingService } from 'vs/platform/keybinding/common/keybinding';
 import { IDecorationsService, IResourceDecorationChangeEvent, IDecoration, IDecorationData, IDecorationsProvider } from 'vs/workbench/services/decorations/common/decorations';
 import { IDisposable, toDisposable, Disposable, DisposableStore } from 'vs/base/common/lifecycle';
-import { IEditorGroupsService, IEditorGroup, GroupsOrder, GroupsArrangement, GroupDirection, IMergeGroupOptions, IEditorReplacement, IFindGroupScope, EditorGroupLayout, ICloseEditorOptions, GroupOrientation, ICloseAllEditorsOptions, ICloseEditorsFilter, IEditorDropTargetDelegate, IEditorPart, IAuxiliaryEditorPart, IEditorGroupsContainer, IAuxiliaryEditorPartCreateEvent, IEditorWorkingSet } from 'vs/workbench/services/editor/common/editorGroupsService';
+import { IEditorGroupsService, IEditorGroup, GroupsOrder, GroupsArrangement, GroupDirection, IMergeGroupOptions, IEditorReplacement, IFindGroupScope, EditorGroupLayout, ICloseEditorOptions, GroupOrientation, ICloseAllEditorsOptions, ICloseEditorsFilter, IEditorDropTargetDelegate, IEditorPart, IAuxiliaryEditorPart, IEditorGroupsContainer, IAuxiliaryEditorPartCreateEvent, IEditorWorkingSet, IEditorGroupContextKeyProvider } from 'vs/workbench/services/editor/common/editorGroupsService';
 import { IEditorService, ISaveEditorsOptions, IRevertAllEditorsOptions, PreferredGroup, IEditorsChangeEvent, ISaveEditorsResult } from 'vs/workbench/services/editor/common/editorService';
 import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
 import { IEditorPaneRegistry, EditorPaneDescriptor } from 'vs/workbench/browser/editor';
@@ -867,6 +867,7 @@ export class TestEditorGroupsService implements IEditorGroupsService {
 	centerLayout(active: boolean): void { }
 	isLayoutCentered(): boolean { return false; }
 	createEditorDropTarget(container: HTMLElement, delegate: IEditorDropTargetDelegate): IDisposable { return Disposable.None; }
+	registerContextKeyProvider<T extends ContextKeyValue>(_provider: IEditorGroupContextKeyProvider<T>): IDisposable { throw new Error('not implemented'); }
 
 	partOptions!: IEditorPartOptions;
 	enforcePartOptions(options: IEditorPartOptions): IDisposable { return Disposable.None; }
@@ -1842,6 +1843,8 @@ export class TestEditorPart extends MainEditorPart implements IEditorGroupsServi
 	getWorkingSets(): IEditorWorkingSet[] { throw new Error('Method not implemented.'); }
 	applyWorkingSet(workingSet: IEditorWorkingSet | 'empty'): Promise<boolean> { throw new Error('Method not implemented.'); }
 	deleteWorkingSet(workingSet: IEditorWorkingSet): Promise<boolean> { throw new Error('Method not implemented.'); }
+
+	registerContextKeyProvider<T extends ContextKeyValue>(provider: IEditorGroupContextKeyProvider<T>): IDisposable { throw new Error('Method not implemented.'); }
 }
 
 export async function createEditorPart(instantiationService: IInstantiationService, disposables: DisposableStore): Promise<TestEditorPart> {