grid - make code editor service proper (standalone)

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

@@ -134,7 +134,7 @@ export abstract class AbstractCodeEditorService implements ICodeEditorService {
 	}
 
 	abstract getActiveCodeEditor(): ICodeEditor;
-	abstract openCodeEditor(input: IResourceInput, sideBySide?: boolean): TPromise<ICodeEditor>;
+	abstract openCodeEditor(input: IResourceInput, source: ICodeEditor, sideBySide?: boolean): TPromise<ICodeEditor>;
 }
 
 export class ModelTransientSettingWatcher {

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

@@ -44,7 +44,7 @@ export interface ICodeEditorService {
 	getTransientModelProperty(model: ITextModel, key: string): any;
 
 	getActiveCodeEditor(): ICodeEditor;
-	openCodeEditor(input: IResourceInput, sideBySide?: boolean): TPromise<ICodeEditor>;
+	openCodeEditor(input: IResourceInput, source: ICodeEditor, sideBySide?: boolean): TPromise<ICodeEditor>;
 }
 
 /**

src/vs/editor/browser/services/codeEditorServiceImpl.ts

@@ -69,7 +69,7 @@ export abstract class CodeEditorServiceImpl extends AbstractCodeEditorService {
 	}
 
 	abstract getActiveCodeEditor(): ICodeEditor;
-	abstract openCodeEditor(input: IResourceInput, sideBySide?: boolean): TPromise<ICodeEditor>;
+	abstract openCodeEditor(input: IResourceInput, source: ICodeEditor, sideBySide?: boolean): TPromise<ICodeEditor>;
 }
 
 interface IModelDecorationOptionsProvider extends IDisposable {

src/vs/editor/browser/services/openerService.ts

@@ -81,7 +81,7 @@ export class OpenerService implements IOpenerService {
 			} else if (resource.scheme === Schemas.file) {
 				resource = resource.with({ path: normalize(resource.path) }); // workaround for non-normalized paths (https://github.com/Microsoft/vscode/issues/12954)
 			}
-			promise = this._editorService.openCodeEditor({ resource, options: { selection, } }, options && options.openToSide);
+			promise = this._editorService.openCodeEditor({ resource, options: { selection, } }, this._editorService.getFocusedCodeEditor(), options && options.openToSide);
 		}
 
 		return promise;

src/vs/editor/contrib/goToDefinition/goToDefinitionCommands.ts

@@ -95,7 +95,7 @@ export class DefinitionAction extends EditorAction {
 			} else if (result.length === 1 && idxOfCurrent !== -1) {
 				// only the position at which we are -> adjust selection
 				let [current] = result;
-				this._openReference(editorService, current, false);
+				this._openReference(editor, editorService, current, false);
 
 			} else {
 				// handle multile results
@@ -134,7 +134,7 @@ export class DefinitionAction extends EditorAction {
 			this._openInPeek(editorService, editor, model);
 		} else {
 			let next = model.nearestReference(editor.getModel().uri, editor.getPosition());
-			this._openReference(editorService, next, this._configuration.openToSide).then(editor => {
+			this._openReference(editor, editorService, next, this._configuration.openToSide).then(editor => {
 				if (editor && model.references.length > 1) {
 					this._openInPeek(editorService, editor, model);
 				} else {
@@ -144,7 +144,7 @@ export class DefinitionAction extends EditorAction {
 		}
 	}
 
-	private _openReference(editorService: ICodeEditorService, reference: Location, sideBySide: boolean): TPromise<ICodeEditor> {
+	private _openReference(editor: ICodeEditor, editorService: ICodeEditorService, reference: Location, sideBySide: boolean): TPromise<ICodeEditor> {
 		let { uri, range } = reference;
 		return editorService.openCodeEditor({
 			resource: uri,
@@ -153,7 +153,7 @@ export class DefinitionAction extends EditorAction {
 				revealIfVisible: true,
 				revealInCenterIfOutsideViewport: true
 			}
-		}, sideBySide);
+		}, editor, sideBySide);
 	}
 
 	private _openInPeek(editorService: ICodeEditorService, target: ICodeEditor, model: ReferencesModel) {
@@ -165,7 +165,7 @@ export class DefinitionAction extends EditorAction {
 				},
 				onGoto: (reference) => {
 					controller.closeWidget();
-					return this._openReference(editorService, reference, false);
+					return this._openReference(target, editorService, reference, false);
 				}
 			});
 		} else {

src/vs/editor/contrib/gotoError/gotoError.ts

@@ -242,7 +242,7 @@ class MarkerController implements editorCommon.IEditorContribution {
 			this._editorService.openCodeEditor({
 				resource: related.resource,
 				options: { pinned: true, revealIfOpened: true, selection: Range.lift(related).collapseToStart() }
-			}).then(undefined, onUnexpectedError);
+			}, this._editor).then(undefined, onUnexpectedError);
 			this.closeMarkersNavigation(false);
 		}));
 		this._disposeOnClose.push(this._editor.onDidChangeModel(() => this._cleanUp()));
@@ -350,7 +350,7 @@ class MarkerNavigationAction extends EditorAction {
 		return editorService.openCodeEditor({
 			resource: newMarker.resource,
 			options: { pinned: false, revealIfOpened: true, revealInCenterIfOutsideViewport: true, selection: newMarker }
-		}).then(editor => {
+		}, editor).then(editor => {
 			if (!editor) {
 				return undefined;
 			}

src/vs/editor/contrib/referenceSearch/referencesController.ts

@@ -212,7 +212,7 @@ export abstract class ReferencesController implements editorCommon.IEditorContri
 		return this._editorService.openCodeEditor({
 			resource: ref.uri,
 			options: { selection: range }
-		}).then(openedEditor => {
+		}, this._editor).then(openedEditor => {
 			this._ignoreModelChangeEvent = false;
 
 			if (!openedEditor || openedEditor !== this._editor) {
@@ -241,7 +241,7 @@ export abstract class ReferencesController implements editorCommon.IEditorContri
 		this._editorService.openCodeEditor({
 			resource: uri,
 			options: { selection: range }
-		}, sideBySide);
+		}, this._editor, sideBySide);
 
 		// clear stage
 		if (!sideBySide) {

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

@@ -6,69 +6,51 @@
 
 import { IResourceInput } from 'vs/platform/editor/common/editor';
 import { TPromise } from 'vs/base/common/winjs.base';
-import { ICodeEditor, IDiffEditor, isCodeEditor } from 'vs/editor/browser/editorBrowser';
+import { ICodeEditor } from 'vs/editor/browser/editorBrowser';
 import { CodeEditorServiceImpl } from 'vs/editor/browser/services/codeEditorServiceImpl';
-import { IEditor, ScrollType } from 'vs/editor/common/editorCommon';
+import { ScrollType } from 'vs/editor/common/editorCommon';
 import { windowOpenNoOpener } from 'vs/base/browser/dom';
 import { Schemas } from 'vs/base/common/network';
 import { IRange } from 'vs/editor/common/core/range';
 import { ITextModel } from 'vs/editor/common/model';
+import URI from 'vs/base/common/uri';
 
 export class StandaloneCodeEditorServiceImpl extends CodeEditorServiceImpl {
-	private editor: IEditor;
-
-	addCodeEditor(editor: ICodeEditor): void {
-		super.addCodeEditor(editor);
-
-		if (!this.editor) {
-			this.editor = editor;
-		}
-	}
-
-	addDiffEditor(editor: IDiffEditor): void {
-		super.addDiffEditor(editor);
-
-		if (!this.editor) {
-			this.editor = editor;
-		}
-	}
 
 	public getActiveCodeEditor(): ICodeEditor {
 		return null; // not supported in the standalone case
 	}
 
-	public openCodeEditor(typedData: IResourceInput, sideBySide?: boolean): TPromise<ICodeEditor> {
-		return TPromise.as(withTypedEditor(this.editor,
-			(editor) => this.doOpenEditor(editor, typedData),
-			(diffEditor) => (
-				this.doOpenEditor(diffEditor.getOriginalEditor(), typedData) ||
-				this.doOpenEditor(diffEditor.getModifiedEditor(), typedData)
-			)
-		));
+	public openCodeEditor(input: IResourceInput, source: ICodeEditor, sideBySide?: boolean): TPromise<ICodeEditor> {
+		if (!source) {
+			return TPromise.as(null);
+		}
+
+		return TPromise.as(this.doOpenEditor(source, input));
 	}
 
-	private doOpenEditor(editor: ICodeEditor, data: IResourceInput): ICodeEditor {
-		let model = this.findModel(editor, data);
+	private doOpenEditor(editor: ICodeEditor, input: IResourceInput): ICodeEditor {
+		const model = this.findModel(editor, input.resource);
 		if (!model) {
-			if (data.resource) {
+			if (input.resource) {
 
-				let schema = data.resource.scheme;
+				const schema = input.resource.scheme;
 				if (schema === Schemas.http || schema === Schemas.https) {
 					// This is a fully qualified http or https URL
-					windowOpenNoOpener(data.resource.toString());
+					windowOpenNoOpener(input.resource.toString());
 					return editor;
 				}
 			}
 			return null;
 		}
 
-		let selection = <IRange>data.options.selection;
+		const selection = <IRange>input.options.selection;
 		if (selection) {
 			if (typeof selection.endLineNumber === 'number' && typeof selection.endColumn === 'number') {
 				editor.setSelection(selection);
 				editor.revealRangeInCenter(selection, ScrollType.Immediate);
 			} else {
-				let pos = {
+				const pos = {
 					lineNumber: selection.startLineNumber,
 					column: selection.startColumn
 				};
@@ -80,22 +62,12 @@ export class StandaloneCodeEditorServiceImpl extends CodeEditorServiceImpl {
 		return editor;
 	}
 
-	private findModel(editor: ICodeEditor, data: IResourceInput): ITextModel {
-		let model = editor.getModel();
-		if (model.uri.toString() !== data.resource.toString()) {
+	private findModel(editor: ICodeEditor, resource: URI): ITextModel {
+		const model = editor.getModel();
+		if (model.uri.toString() !== resource.toString()) {
 			return null;
 		}
 
 		return model;
 	}
 }
-
-function withTypedEditor<T>(widget: IEditor, codeEditorCallback: (editor: ICodeEditor) => T, diffEditorCallback: (editor: IDiffEditor) => T): T {
-	if (isCodeEditor(widget)) {
-		// Single Editor
-		return codeEditorCallback(<ICodeEditor>widget);
-	} else {
-		// Diff Editor
-		return diffEditorCallback(<IDiffEditor>widget);
-	}
-}
\ No newline at end of file

src/vs/editor/test/browser/editorTestServices.ts

@@ -17,7 +17,7 @@ import { IResourceInput } from 'vs/platform/editor/common/editor';
 export class TestCodeEditorService extends AbstractCodeEditorService {
 	public lastInput: IResourceInput;
 	public getActiveCodeEditor(): ICodeEditor { return null; }
-	public openCodeEditor(input: IResourceInput, sideBySide?: boolean): TPromise<ICodeEditor> {
+	public openCodeEditor(input: IResourceInput, source: ICodeEditor, sideBySide?: boolean): TPromise<ICodeEditor> {
 		this.lastInput = input;
 		return TPromise.as(null);
 	}

src/vs/editor/test/browser/services/decorationRenderOptions.test.ts

@@ -21,7 +21,7 @@ export class TestCodeEditorServiceImpl extends CodeEditorServiceImpl {
 		return null;
 	}
 
-	openCodeEditor(input: IResourceInput, sideBySide?: boolean): TPromise<ICodeEditor> {
+	openCodeEditor(input: IResourceInput, source: ICodeEditor, sideBySide?: boolean): TPromise<ICodeEditor> {
 		return TPromise.as(null);
 	}
 }

src/vs/workbench/services/codeEditor/browser/codeEditorService.ts

@@ -34,7 +34,7 @@ export class CodeEditorService extends CodeEditorServiceImpl {
 		return null;
 	}
 
-	openCodeEditor(input: IResourceInput, sideBySide?: boolean): TPromise<ICodeEditor> {
+	openCodeEditor(input: IResourceInput, source: ICodeEditor, sideBySide?: boolean): TPromise<ICodeEditor> {
 		return this.editorService.openEditor(input, sideBySide ? SIDE_GROUP : ACTIVE_GROUP).then(control => {
 			if (control) {
 				const widget = control.getControl();

src/vs/workbench/test/workbenchTestServices.ts

@@ -1132,7 +1132,7 @@ export class TestCodeEditorService implements ICodeEditorService {
 	setTransientModelProperty(model: ITextModel, key: string, value: any): void { }
 	getTransientModelProperty(model: ITextModel, key: string) { }
 	getActiveCodeEditor(): ICodeEditor { return null; }
-	openCodeEditor(input: IResourceInput, sideBySide?: boolean): TPromise<ICodeEditor> { return TPromise.as(null); }
+	openCodeEditor(input: IResourceInput, source: ICodeEditor, sideBySide?: boolean): TPromise<ICodeEditor> { return TPromise.as(null); }
 }
 
 export class TestWindowService implements IWindowService {