✨ ICodeEditorService.listDiffEditors()

src/vs/editor/browser/standalone/standaloneCodeEditor.ts

@@ -280,14 +280,15 @@ export class StandaloneDiffEditor extends DiffEditorWidget implements IStandalon
 		@IKeybindingService keybindingService: IKeybindingService,
 		@IContextViewService contextViewService: IContextViewService,
 		@IStandaloneThemeService standaloneColorService: IStandaloneThemeService,
-		@IEditorWorkerService editorWorkerService: IEditorWorkerService
+		@IEditorWorkerService editorWorkerService: IEditorWorkerService,
+		@ICodeEditorService codeEditorService: ICodeEditorService
 	) {
 		options = options || {};
 		if (typeof options.theme === 'string') {
 			options.theme = standaloneColorService.setTheme(options.theme);
 		}
 
-		super(domElement, options, editorWorkerService, contextKeyService, instantiationService);
+		super(domElement, options, editorWorkerService, contextKeyService, instantiationService, codeEditorService);
 
 		if (keybindingService instanceof StandaloneKeybindingService) {
 			this._standaloneKeybindingService = keybindingService;

src/vs/editor/browser/standalone/standaloneEditor.ts

@@ -124,7 +124,8 @@ export function createDiffEditor(domElement: HTMLElement, options?: IDiffEditorC
 			services.get(IKeybindingService),
 			services.get(IContextViewService),
 			services.get(IStandaloneThemeService),
-			services.get(IEditorWorkerService)
+			services.get(IEditorWorkerService),
+			services.get(ICodeEditorService)
 		);
 	});
 }

src/vs/editor/browser/widget/diffEditorWidget.ts

@@ -15,6 +15,7 @@ import { FastDomNode, createFastDomNode } from 'vs/base/browser/fastDomNode';
 import { ISashEvent, IVerticalSashLayoutProvider, Sash } from 'vs/base/browser/ui/sash/sash';
 import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
 import { IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
+import { ICodeEditorService } from 'vs/editor/common/services/codeEditorService';
 import { DefaultConfig } from 'vs/editor/common/config/defaultConfig';
 import { Range } from 'vs/editor/common/core/range';
 import * as editorCommon from 'vs/editor/common/editorCommon';
@@ -204,16 +205,19 @@ export class DiffEditorWidget extends EventEmitter implements editorBrowser.IDif
 
 	private _editorWorkerService: IEditorWorkerService;
 	protected _contextKeyService: IContextKeyService;
+	private _codeEditorService: ICodeEditorService;
 
 	constructor(
 		domElement: HTMLElement,
 		options: editorCommon.IDiffEditorOptions,
 		@IEditorWorkerService editorWorkerService: IEditorWorkerService,
 		@IContextKeyService contextKeyService: IContextKeyService,
-		@IInstantiationService instantiationService: IInstantiationService
+		@IInstantiationService instantiationService: IInstantiationService,
+		@ICodeEditorService codeEditorService: ICodeEditorService
 	) {
 		super();
 		this._editorWorkerService = editorWorkerService;
+		this._codeEditorService = codeEditorService;
 		this._contextKeyService = contextKeyService.createScoped(domElement);
 		this._contextKeyService.createKey('isInDiffEditor', true);
 
@@ -314,6 +318,8 @@ export class DiffEditorWidget extends EventEmitter implements editorBrowser.IDif
 		} else {
 			this._setStrategy(new DiffEdtorWidgetInline(this._createDataSource(), this._enableSplitViewResizing));
 		}
+
+		this._codeEditorService.addDiffEditor(this);
 	}
 
 	public get ignoreTrimWhitespace(): boolean {
@@ -392,6 +398,8 @@ export class DiffEditorWidget extends EventEmitter implements editorBrowser.IDif
 	}
 
 	public dispose(): void {
+		this._codeEditorService.removeDiffEditor(this);
+
 		this._toDispose = dispose(this._toDispose);
 
 		window.clearInterval(this._measureDomElementToken);

src/vs/editor/common/services/abstractCodeEditorService.ts

@@ -5,51 +5,85 @@
 'use strict';
 
 import Event, { Emitter } from 'vs/base/common/event';
-import { ICommonCodeEditor, IDecorationRenderOptions, IModelDecorationOptions } from 'vs/editor/common/editorCommon';
+import { ICommonCodeEditor, ICommonDiffEditor, IDecorationRenderOptions, IModelDecorationOptions } from 'vs/editor/common/editorCommon';
 import { ICodeEditorService } from 'vs/editor/common/services/codeEditorService';
 
 export abstract class AbstractCodeEditorService implements ICodeEditorService {
-	public _serviceBrand: any;
+
+	_serviceBrand: any;
+
 	private _onCodeEditorAdd: Emitter<ICommonCodeEditor>;
 	private _onCodeEditorRemove: Emitter<ICommonCodeEditor>;
-	private _codeEditors: {
-		[editorId: string]: ICommonCodeEditor;
-	};
+	private _codeEditors: { [editorId: string]: ICommonCodeEditor; };
+
+	private _onDiffEditorAdd: Emitter<ICommonDiffEditor>;
+	private _onDiffEditorRemove: Emitter<ICommonDiffEditor>;
+	private _diffEditors: { [editorId: string]: ICommonDiffEditor; };
 
 	constructor() {
 		this._codeEditors = Object.create(null);
+		this._diffEditors = Object.create(null);
 		this._onCodeEditorAdd = new Emitter<ICommonCodeEditor>();
 		this._onCodeEditorRemove = new Emitter<ICommonCodeEditor>();
+		this._onDiffEditorAdd = new Emitter<ICommonDiffEditor>();
+		this._onDiffEditorRemove = new Emitter<ICommonDiffEditor>();
 	}
 
-	public addCodeEditor(editor: ICommonCodeEditor): void {
+	addCodeEditor(editor: ICommonCodeEditor): void {
 		this._codeEditors[editor.getId()] = editor;
 		this._onCodeEditorAdd.fire(editor);
 	}
 
-	public get onCodeEditorAdd(): Event<ICommonCodeEditor> {
+	get onCodeEditorAdd(): Event<ICommonCodeEditor> {
 		return this._onCodeEditorAdd.event;
 	}
 
-	public removeCodeEditor(editor: ICommonCodeEditor): void {
+	removeCodeEditor(editor: ICommonCodeEditor): void {
 		if (delete this._codeEditors[editor.getId()]) {
 			this._onCodeEditorRemove.fire(editor);
 		}
 	}
 
-	public get onCodeEditorRemove(): Event<ICommonCodeEditor> {
+	get onCodeEditorRemove(): Event<ICommonCodeEditor> {
 		return this._onCodeEditorRemove.event;
 	}
 
-	public getCodeEditor(editorId: string): ICommonCodeEditor {
+	getCodeEditor(editorId: string): ICommonCodeEditor {
 		return this._codeEditors[editorId] || null;
 	}
 
-	public listCodeEditors(): ICommonCodeEditor[] {
+	listCodeEditors(): ICommonCodeEditor[] {
 		return Object.keys(this._codeEditors).map(id => this._codeEditors[id]);
 	}
 
-	public getFocusedCodeEditor(): ICommonCodeEditor {
+	addDiffEditor(editor: ICommonDiffEditor): void {
+		this._diffEditors[editor.getId()] = editor;
+		this._onDiffEditorAdd.fire(editor);
+	}
+
+	get onDiffEditorAdd(): Event<ICommonDiffEditor> {
+		return this._onDiffEditorAdd.event;
+	}
+
+	removeDiffEditor(editor: ICommonDiffEditor): void {
+		if (delete this._diffEditors[editor.getId()]) {
+			this._onDiffEditorRemove.fire(editor);
+		}
+	}
+
+	get onDiffEditorRemove(): Event<ICommonDiffEditor> {
+		return this._onDiffEditorRemove.event;
+	}
+
+	getDiffEditor(editorId: string): ICommonDiffEditor {
+		return this._diffEditors[editorId] || null;
+	}
+
+	listDiffEditors(): ICommonDiffEditor[] {
+		return Object.keys(this._diffEditors).map(id => this._diffEditors[id]);
+	}
+
+	getFocusedCodeEditor(): ICommonCodeEditor {
 		let editorWithWidgetFocus: ICommonCodeEditor = null;
 
 		let editors = this.listCodeEditors();
@@ -69,7 +103,7 @@ export abstract class AbstractCodeEditorService implements ICodeEditorService {
 		return editorWithWidgetFocus;
 	}
 
-	public abstract registerDecorationType(key: string, options: IDecorationRenderOptions, parentTypeKey?: string): void;
-	public abstract removeDecorationType(key: string): void;
-	public abstract resolveDecorationOptions(decorationTypeKey: string, writable: boolean): IModelDecorationOptions;
+	abstract registerDecorationType(key: string, options: IDecorationRenderOptions, parentTypeKey?: string): void;
+	abstract removeDecorationType(key: string): void;
+	abstract resolveDecorationOptions(decorationTypeKey: string, writable: boolean): IModelDecorationOptions;
 }

src/vs/editor/common/services/codeEditorService.ts

@@ -14,16 +14,22 @@ export var ICodeEditorService = createDecorator<ICodeEditorService>('codeEditorS
 export interface ICodeEditorService {
 	_serviceBrand: any;
 
-	addCodeEditor(editor: ICommonCodeEditor): void;
 	onCodeEditorAdd: Event<ICommonCodeEditor>;
-
-	removeCodeEditor(editor: ICommonCodeEditor): void;
 	onCodeEditorRemove: Event<ICommonCodeEditor>;
 
-	getCodeEditor(editorId: string): ICommonCodeEditor;
+	onDiffEditorAdd: Event<ICommonDiffEditor>;
+	onDiffEditorRemove: Event<ICommonDiffEditor>;
 
+	addCodeEditor(editor: ICommonCodeEditor): void;
+	removeCodeEditor(editor: ICommonCodeEditor): void;
+	getCodeEditor(editorId: string): ICommonCodeEditor;
 	listCodeEditors(): ICommonCodeEditor[];
 
+	addDiffEditor(editor: ICommonDiffEditor): void;
+	removeDiffEditor(editor: ICommonDiffEditor): void;
+	getDiffEditor(editorId: string): ICommonDiffEditor;
+	listDiffEditors(): ICommonDiffEditor[];
+
 	/**
 	 * Returns the current focused code editor (if the focus is in the editor or in an editor widget) or null.
 	 */