Benibenj/registerContextKeyHandler

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

@@ -190,6 +190,7 @@ export interface IEditorPartsView {
 	createAuxiliaryEditorPart(options?: IAuxiliaryWindowOpenOptions): Promise<IAuxiliaryEditorPart>;
 
 	bind<T extends ContextKeyValue>(contextKey: RawContextKey<T>, group: IEditorGroupView): IContextKey<T>;
+	runRegisteredContextProviders(group: IEditorGroupView): void;
 }
 
 /**

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

@@ -297,6 +297,7 @@ export class EditorGroupView extends Themable implements IEditorGroupView {
 					sideBySideEditorContext.set(false);
 					groupActiveEditorDirtyContext.set(false);
 				}
+				this.editorPartsView.runRegisteredContextProviders(this);
 
 				if (activeEditorPane) {
 					groupActiveEditorContext.set(activeEditorPane.getId());

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

@@ -4,7 +4,7 @@
  *--------------------------------------------------------------------------------------------*/
 
 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, IContextKeyProvider, 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 { GroupIdentifier } from 'vs/workbench/common/editor';
@@ -700,6 +700,68 @@ export class EditorParts extends MultiWindowParts<EditorPart> implements IEditor
 		if (groupScopedContextKeys) {
 			this.scopedContextKeys.delete(group.id);
 		}
+
+		const registeredContextKeys = this.registeredContextKeys.get(group.id);
+		if (registeredContextKeys) {
+			this.registeredContextKeys.delete(group.id);
+		}
+	}
+
+	private readonly contextKeyProviders = new Map<string, IContextKeyProvider>();
+	private readonly registeredContextKeys = new Map<GroupIdentifier, Map<string, IContextKey>>();
+
+	registerContextKeyProvider(provider: IContextKeyProvider): IDisposable {
+		if (this.contextKeyProviders.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 = () => {
+			this.groups.forEach(group => {
+				this.runRegisteredContextKeyProvider(group, provider);
+			});
+		};
+
+		// Run initially
+		setContextKeyForGroups();
+
+		// Run when a change is registered for the provider
+		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));
+		});
+	}
+
+	runRegisteredContextProviders(group: IEditorGroupView): void {
+		// Run all registered context key providers for the group
+		for (const contextKeyProvider of this.contextKeyProviders.values()) {
+			this.runRegisteredContextKeyProvider(group, contextKeyProvider);
+		}
+	}
+
+	private runRegisteredContextKeyProvider(group: IEditorGroupView, provider: IContextKeyProvider): 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 { IContextKeyProvider, 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,101 @@ 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 hasChangesContextKeyProvider: IDisposable;
+	private repositoryContextKeyProvider: 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: IContextKeyProvider = {
+			contextKey: activeResourceHasChangesContextKey,
+			getGroupContextKeyValue: (group) => this.getEditorHasChanges(group.activeEditor),
+			onDidChange: this.onDidRepositoryChange.event
+		};
+
+		const repositoryContextKeyProvider: IContextKeyProvider = {
+			contextKey: activeResourceRepositoryContextKey,
+			getGroupContextKeyValue: (group) => this.getEditorRepositoryId(group.activeEditor),
+			onDidChange: this.onDidRepositoryChange.event
+		};
+
+		this.hasChangesContextKeyProvider = editorGroupsService.registerContextKeyProvider(hasChangesContextKeyProvider);
+		this.repositoryContextKeyProvider = 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.hasChangesContextKeyProvider.dispose();
+		this.repositoryContextKeyProvider.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 IContextKeyProvider {
+	/**
+	 * The context key that needs to be set for each editor group context and the global context.
+	 */
+	readonly contextKey: RawContextKey<ContextKeyValue>;
+
+	/**
+	 * Retrieves the context key value for the given editor group.
+	 */
+	readonly getGroupContextKeyValue: (group: IEditorGroup) => ContextKeyValue;
+
+	/**
+	 * 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(provider: IContextKeyProvider): IDisposable;
 }
 
 export const enum OpenEditorContext {

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

@@ -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, IContextKeyProvider } 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(_provider: IContextKeyProvider): 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(provider: IContextKeyProvider): IDisposable { throw new Error('Method not implemented.'); }
 }
 
 export async function createEditorPart(instantiationService: IInstantiationService, disposables: DisposableStore): Promise<TestEditorPart> {