move commands to references controller

ae03a05c · Johannes Rieken · 05b1d4b7 · ae03a05c · ae03a05c · ae03a05c
3 changed file
--- a/src/vs/editor/contrib/referenceSearch/peekViewWidget.ts
+++ b/src/vs/editor/contrib/referenceSearch/peekViewWidget.ts
@@ -17,11 +17,13 @@ import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService
 import { EmbeddedCodeEditorWidget } from 'vs/editor/browser/widget/embeddedCodeEditorWidget';
 import { IOptions, IStyles, ZoneWidget } from 'vs/editor/contrib/zoneWidget/zoneWidget';
 import * as nls from 'vs/nls';
-import { ContextKeyExpr, RawContextKey } from 'vs/platform/contextkey/common/contextkey';
+import { ContextKeyExpr, RawContextKey, IContextKeyService } from 'vs/platform/contextkey/common/contextkey';
 import { ServicesAccessor, createDecorator } from 'vs/platform/instantiation/common/instantiation';
 import { IDisposable } from 'vs/base/common/lifecycle';
 import { registerSingleton } from 'vs/platform/instantiation/common/extensions';
 import { EditorOption } from 'vs/editor/common/config/editorOptions';
+import { registerEditorContribution } from 'vs/editor/browser/editorExtensions';
+import { IEditorContribution } from 'vs/editor/common/editorCommon';


 export const IPeekViewService = createDecorator<IPeekViewService>('IPeekViewService');
@@ -57,6 +59,24 @@ export namespace PeekContext {
 	export const notInPeekEditor: ContextKeyExpr = inPeekEditor.toNegated();
 }

+class PeekContextController implements IEditorContribution {
+
+	static readonly ID = 'editor.contrib.referenceController';
+
+	constructor(
+		editor: ICodeEditor,
+		@IContextKeyService contextKeyService: IContextKeyService
+	) {
+		if (editor instanceof EmbeddedCodeEditorWidget) {
+			PeekContext.inPeekEditor.bindTo(contextKeyService);
+		}
+	}
+
+	dispose(): void { }
+}
+
+registerEditorContribution(PeekContextController.ID, PeekContextController);
+
 export function getOuterEditor(accessor: ServicesAccessor): ICodeEditor | null {
 	let editor = accessor.get(ICodeEditorService).getFocusedCodeEditor();
 	if (editor instanceof EmbeddedCodeEditorWidget) {

--- a/src/vs/editor/contrib/referenceSearch/referenceSearch.ts
+++ b/src/vs/editor/contrib/referenceSearch/referenceSearch.ts
@@ -4,54 +4,26 @@
 *--------------------------------------------------------------------------------------------*/

 import * as nls from 'vs/nls';
-import { KeyCode, KeyMod } from 'vs/base/common/keyCodes';
-import { IContextKeyService, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
-import { KeybindingsRegistry, KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';
 import { Position, IPosition } from 'vs/editor/common/core/position';
-import * as editorCommon from 'vs/editor/common/editorCommon';
-import { ServicesAccessor, registerEditorContribution } from 'vs/editor/browser/editorExtensions';
+import { ServicesAccessor } from 'vs/editor/browser/editorExtensions';
 import { Location } from 'vs/editor/common/modes';
 import { Range } from 'vs/editor/common/core/range';
-import { PeekContext, getOuterEditor } from './peekViewWidget';
-import { ReferencesController, RequestOptions, ctxReferenceSearchVisible } from './referencesController';
-import { ReferencesModel, OneReference } from './referencesModel';
+import { ReferencesController, RequestOptions } from './referencesController';
+import { ReferencesModel } from './referencesModel';
 import { createCancelablePromise } from 'vs/base/common/async';
-import { EmbeddedCodeEditorWidget } from 'vs/editor/browser/widget/embeddedCodeEditorWidget';
-import { ICodeEditor, isCodeEditor } from 'vs/editor/browser/editorBrowser';
-import { IListService } from 'vs/platform/list/browser/listService';
-import { ctxReferenceWidgetSearchTreeFocused } from 'vs/editor/contrib/referenceSearch/referencesWidget';
+import { isCodeEditor } from 'vs/editor/browser/editorBrowser';
 import { CommandsRegistry, ICommandHandler } from 'vs/platform/commands/common/commands';
 import { URI } from 'vs/base/common/uri';
 import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
 import { getReferencesAtPosition } from 'vs/editor/contrib/goToDefinition/goToDefinition';

-export const defaultReferenceSearchOptions: RequestOptions = {
+const defaultReferenceSearchOptions: RequestOptions = {
 	getMetaTitle(model) {
 		return model.references.length > 1 ? nls.localize('meta.titleReference', " – {0} references", model.references.length) : '';
 	}
 };

-class ReferenceController implements editorCommon.IEditorContribution {
-
-	public static readonly ID = 'editor.contrib.referenceController';
-
-	constructor(
-		editor: ICodeEditor,
-		@IContextKeyService contextKeyService: IContextKeyService
-	) {
-		if (editor instanceof EmbeddedCodeEditorWidget) {
-			PeekContext.inPeekEditor.bindTo(contextKeyService);
-		}
-	}
-
-	public dispose(): void {
-	}
-}
-
-registerEditorContribution(ReferenceController.ID, ReferenceController);
-
-
-let findReferencesCommand: ICommandHandler = (accessor: ServicesAccessor, resource: URI, position: IPosition) => {
+const findReferencesCommand: ICommandHandler = (accessor: ServicesAccessor, resource: URI, position: IPosition) => {
 	if (!(resource instanceof URI)) {
 		throw new Error('illegal argument, uri');
 	}
@@ -76,7 +48,7 @@ let findReferencesCommand: ICommandHandler = (accessor: ServicesAccessor, resour
 	});
 };

-let showReferencesCommand: ICommandHandler = (accessor: ServicesAccessor, resource: URI, position: IPosition, references: Location[]) => {
+const showReferencesCommand: ICommandHandler = (accessor: ServicesAccessor, resource: URI, position: IPosition, references: Location[]) => {
 	if (!(resource instanceof URI)) {
 		throw new Error('illegal argument, uri expected');
 	}
@@ -124,106 +96,3 @@ CommandsRegistry.registerCommand({
 	}
 });

-function closeActiveReferenceSearch(accessor: ServicesAccessor) {
-	withController(accessor, controller => controller.closeWidget());
-}
-
-function openReferenceToSide(accessor: ServicesAccessor) {
-	const listService = accessor.get(IListService);
-
-	const focus = listService.lastFocusedList && listService.lastFocusedList.getFocus();
-	if (focus instanceof OneReference) {
-		withController(accessor, controller => controller.openReference(focus, true));
-	}
-}
-
-function withController(accessor: ServicesAccessor, fn: (controller: ReferencesController) => void): void {
-	const outerEditor = getOuterEditor(accessor);
-	if (!outerEditor) {
-		return;
-	}
-
-	let controller = ReferencesController.get(outerEditor);
-	if (!controller) {
-		return;
-	}
-
-	fn(controller);
-}
-
-KeybindingsRegistry.registerCommandAndKeybindingRule({
-	id: 'goToNextReference',
-	weight: KeybindingWeight.WorkbenchContrib + 50,
-	primary: KeyCode.F4,
-	when: ctxReferenceSearchVisible,
-	handler(accessor) {
-		withController(accessor, controller => {
-			controller.goToNextOrPreviousReference(true);
-		});
-	}
-});
-
-KeybindingsRegistry.registerCommandAndKeybindingRule({
-	id: 'goToNextReferenceFromEmbeddedEditor',
-	weight: KeybindingWeight.EditorContrib + 50,
-	primary: KeyCode.F4,
-	when: PeekContext.inPeekEditor,
-	handler(accessor) {
-		withController(accessor, controller => {
-			controller.goToNextOrPreviousReference(true);
-		});
-	}
-});
-
-KeybindingsRegistry.registerCommandAndKeybindingRule({
-	id: 'goToPreviousReference',
-	weight: KeybindingWeight.WorkbenchContrib + 50,
-	primary: KeyMod.Shift | KeyCode.F4,
-	when: ctxReferenceSearchVisible,
-	handler(accessor) {
-		withController(accessor, controller => {
-			controller.goToNextOrPreviousReference(false);
-		});
-	}
-});
-
-KeybindingsRegistry.registerCommandAndKeybindingRule({
-	id: 'goToPreviousReferenceFromEmbeddedEditor',
-	weight: KeybindingWeight.EditorContrib + 50,
-	primary: KeyMod.Shift | KeyCode.F4,
-	when: PeekContext.inPeekEditor,
-	handler(accessor) {
-		withController(accessor, controller => {
-			controller.goToNextOrPreviousReference(false);
-		});
-	}
-});
-
-KeybindingsRegistry.registerCommandAndKeybindingRule({
-	id: 'closeReferenceSearch',
-	weight: KeybindingWeight.WorkbenchContrib + 50,
-	primary: KeyCode.Escape,
-	secondary: [KeyMod.Shift | KeyCode.Escape],
-	when: ContextKeyExpr.and(ctxReferenceSearchVisible, ContextKeyExpr.not('config.editor.stablePeek')),
-	handler: closeActiveReferenceSearch
-});
-
-KeybindingsRegistry.registerCommandAndKeybindingRule({
-	id: 'closeReferenceSearchEditor',
-	weight: KeybindingWeight.EditorContrib - 101,
-	primary: KeyCode.Escape,
-	secondary: [KeyMod.Shift | KeyCode.Escape],
-	when: ContextKeyExpr.and(PeekContext.inPeekEditor, ContextKeyExpr.not('config.editor.stablePeek')),
-	handler: closeActiveReferenceSearch
-});
-
-KeybindingsRegistry.registerCommandAndKeybindingRule({
-	id: 'openReferenceToSide',
-	weight: KeybindingWeight.EditorContrib,
-	primary: KeyMod.CtrlCmd | KeyCode.Enter,
-	mac: {
-		primary: KeyMod.WinCtrl | KeyCode.Enter
-	},
-	when: ContextKeyExpr.and(ctxReferenceSearchVisible, ctxReferenceWidgetSearchTreeFocused),
-	handler: openReferenceToSide
-});
--- a/src/vs/editor/contrib/referenceSearch/referencesController.ts
+++ b/src/vs/editor/contrib/referenceSearch/referencesController.ts
@@ -7,19 +7,23 @@ import * as nls from 'vs/nls';
 import { onUnexpectedError } from 'vs/base/common/errors';
 import { dispose, DisposableStore } from 'vs/base/common/lifecycle';
 import { ICodeEditorService } from 'vs/editor/browser/services/codeEditorService';
-import { IInstantiationService } from 'vs/platform/instantiation/common/instantiation';
-import { IContextKey, IContextKeyService, RawContextKey } from 'vs/platform/contextkey/common/contextkey';
+import { IInstantiationService, ServicesAccessor } from 'vs/platform/instantiation/common/instantiation';
+import { IContextKey, IContextKeyService, RawContextKey, ContextKeyExpr } from 'vs/platform/contextkey/common/contextkey';
 import { IConfigurationService } from 'vs/platform/configuration/common/configuration';
 import { IStorageService, StorageScope } from 'vs/platform/storage/common/storage';
 import * as editorCommon from 'vs/editor/common/editorCommon';
 import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
-import { ReferencesModel } from './referencesModel';
-import { ReferenceWidget, LayoutData } from './referencesWidget';
+import { ReferencesModel, OneReference } from './referencesModel';
+import { ReferenceWidget, LayoutData, ctxReferenceWidgetSearchTreeFocused } from './referencesWidget';
 import { Range } from 'vs/editor/common/core/range';
 import { Position } from 'vs/editor/common/core/position';
 import { Location } from 'vs/editor/common/modes';
 import { INotificationService } from 'vs/platform/notification/common/notification';
 import { CancelablePromise } from 'vs/base/common/async';
+import { getOuterEditor, PeekContext } from 'vs/editor/contrib/referenceSearch/peekViewWidget';
+import { IListService } from 'vs/platform/list/browser/listService';
+import { KeybindingsRegistry, KeybindingWeight } from 'vs/platform/keybinding/common/keybindingsRegistry';
+import { KeyCode, KeyMod } from 'vs/base/common/keyCodes';

 export const ctxReferenceSearchVisible = new RawContextKey<boolean>('referenceSearchVisible', false);

@@ -33,7 +37,7 @@ export abstract class ReferencesController implements editorCommon.IEditorContri
 	static readonly ID = 'editor.contrib.referencesController';

 	private readonly _disposables = new DisposableStore();
-	private readonly _editor: ICodeEditor;
+
 	private _widget?: ReferenceWidget;
 	private _model?: ReferencesModel;
 	private _requestIdPool = 0;
@@ -47,7 +51,7 @@ export abstract class ReferencesController implements editorCommon.IEditorContri

 	constructor(
 		private readonly _defaultTreeKeyboardSupport: boolean,
-		editor: ICodeEditor,
+		private readonly _editor: ICodeEditor,
 		@IContextKeyService contextKeyService: IContextKeyService,
 		@ICodeEditorService private readonly _editorService: ICodeEditorService,
 		@INotificationService private readonly _notificationService: INotificationService,
@@ -55,21 +59,17 @@ export abstract class ReferencesController implements editorCommon.IEditorContri
 		@IStorageService private readonly _storageService: IStorageService,
 		@IConfigurationService private readonly _configurationService: IConfigurationService,
 	) {
-		this._editor = editor;
+
 		this._referenceSearchVisible = ctxReferenceSearchVisible.bindTo(contextKeyService);
 	}

 	dispose(): void {
 		this._referenceSearchVisible.reset();
-		dispose(this._disposables);
-		if (this._widget) {
-			dispose(this._widget);
-			this._widget = undefined;
-		}
-		if (this._model) {
-			dispose(this._model);
-			this._model = undefined;
-		}
+		this._disposables.dispose();
+		dispose(this._widget);
+		dispose(this._model);
+		this._widget = undefined;
+		this._model = undefined;
 	}

 	toggleWidget(range: Range, modelPromise: CancelablePromise<ReferencesModel>, options: RequestOptions): void {
@@ -260,3 +260,101 @@ export abstract class ReferencesController implements editorCommon.IEditorContri
 		}, this._editor, sideBySide);
 	}
 }
+
+function withController(accessor: ServicesAccessor, fn: (controller: ReferencesController) => void): void {
+	const outerEditor = getOuterEditor(accessor);
+	if (!outerEditor) {
+		return;
+	}
+	let controller = ReferencesController.get(outerEditor);
+	if (controller) {
+		fn(controller);
+	}
+}
+
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+	id: 'goToNextReference',
+	weight: KeybindingWeight.WorkbenchContrib + 50,
+	primary: KeyCode.F4,
+	when: ctxReferenceSearchVisible,
+	handler(accessor) {
+		withController(accessor, controller => {
+			controller.goToNextOrPreviousReference(true);
+		});
+	}
+});
+
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+	id: 'goToNextReferenceFromEmbeddedEditor',
+	weight: KeybindingWeight.EditorContrib + 50,
+	primary: KeyCode.F4,
+	when: PeekContext.inPeekEditor,
+	handler(accessor) {
+		withController(accessor, controller => {
+			controller.goToNextOrPreviousReference(true);
+		});
+	}
+});
+
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+	id: 'goToPreviousReference',
+	weight: KeybindingWeight.WorkbenchContrib + 50,
+	primary: KeyMod.Shift | KeyCode.F4,
+	when: ctxReferenceSearchVisible,
+	handler(accessor) {
+		withController(accessor, controller => {
+			controller.goToNextOrPreviousReference(false);
+		});
+	}
+});
+
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+	id: 'goToPreviousReferenceFromEmbeddedEditor',
+	weight: KeybindingWeight.EditorContrib + 50,
+	primary: KeyMod.Shift | KeyCode.F4,
+	when: PeekContext.inPeekEditor,
+	handler(accessor) {
+		withController(accessor, controller => {
+			controller.goToNextOrPreviousReference(false);
+		});
+	}
+});
+
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+	id: 'closeReferenceSearch',
+	weight: KeybindingWeight.WorkbenchContrib + 50,
+	primary: KeyCode.Escape,
+	secondary: [KeyMod.Shift | KeyCode.Escape],
+	when: ContextKeyExpr.and(ctxReferenceSearchVisible, ContextKeyExpr.not('config.editor.stablePeek')),
+	handler(accessor: ServicesAccessor) {
+		withController(accessor, controller => controller.closeWidget());
+	}
+});
+
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+	id: 'closeReferenceSearchEditor',
+	weight: KeybindingWeight.EditorContrib - 101,
+	primary: KeyCode.Escape,
+	secondary: [KeyMod.Shift | KeyCode.Escape],
+	when: ContextKeyExpr.and(PeekContext.inPeekEditor, ContextKeyExpr.not('config.editor.stablePeek')),
+	handler(accessor: ServicesAccessor) {
+		withController(accessor, controller => controller.closeWidget());
+	}
+});
+
+KeybindingsRegistry.registerCommandAndKeybindingRule({
+	id: 'openReferenceToSide',
+	weight: KeybindingWeight.EditorContrib,
+	primary: KeyMod.CtrlCmd | KeyCode.Enter,
+	mac: {
+		primary: KeyMod.WinCtrl | KeyCode.Enter
+	},
+	when: ContextKeyExpr.and(ctxReferenceSearchVisible, ctxReferenceWidgetSearchTreeFocused),
+	handler(accessor: ServicesAccessor) {
+		const listService = accessor.get(IListService);
+		const focus = listService.lastFocusedList && listService.lastFocusedList.getFocus();
+		if (focus instanceof OneReference) {
+			withController(accessor, controller => controller.openReference(focus, true));
+		}
+	}
+});