Initial VS Code 1.19 source merge (#571)

* Initial 1.19 xcopy

* Fix yarn build

* Fix numerous build breaks

* Next batch of build break fixes

* More build break fixes

* Runtime breaks

* Additional post merge fixes

* Fix windows setup file

* Fix test failures.

* Update license header blocks to refer to source eula
This commit is contained in:
Karl Burtram
2018-01-28 23:37:17 -08:00
committed by GitHub
parent 9a1ac20710
commit 251ae01c3e
8009 changed files with 93378 additions and 35634 deletions

View File

@@ -4,7 +4,6 @@
*--------------------------------------------------------------------------------------------*/
'use strict';
import { EmitterEvent } from 'vs/base/common/eventEmitter';
import * as strings from 'vs/base/common/strings';
import { Position, IPosition } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
@@ -38,7 +37,6 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
private readonly decorations: ViewModelDecorations;
private _isDisposing: boolean;
private _centeredViewLine: number;
constructor(editorId: number, configuration: editorCommon.IConfiguration, model: editorCommon.IModel, scheduleAtNextAnimationFrame: (callback: () => void) => IDisposable) {
@@ -79,21 +77,11 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
this._emit([new viewEvents.ViewScrollChangedEvent(e)]);
}));
this._isDisposing = false;
this._centeredViewLine = -1;
this.decorations = new ViewModelDecorations(this.editorId, this.model, this.configuration, this.lines, this.coordinatesConverter);
this._register(this.model.addBulkListener((events: EmitterEvent[]) => {
if (this._isDisposing) {
// Disposing the lines might end up sending model decoration changed events
// ...we no longer care about them...
return;
}
let eventsCollector = new ViewEventsCollector();
this._onModelEvents(eventsCollector, events);
this._emit(eventsCollector.finalize());
}));
this._registerModelEvents();
this._register(this.configuration.onDidChange((e) => {
const eventsCollector = new ViewEventsCollector();
@@ -107,10 +95,11 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
}
public dispose(): void {
this._isDisposing = true;
// First remove listeners, as disposing the lines might end up sending
// model decoration changed events ... and we no longer care about them ...
super.dispose();
this.decorations.dispose();
this.lines.dispose();
super.dispose();
}
private _onConfigurationChanged(eventsCollector: ViewEventsCollector, e: IConfigurationChangedEvent): void {
@@ -157,152 +146,119 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
}
}
private _onModelEvents(eventsCollector: ViewEventsCollector, events: EmitterEvent[]): void {
private _registerModelEvents(): void {
// A quick check if there are model content change events incoming
// in order to update the configuration and reset the centered view line
for (let i = 0, len = events.length; i < len; i++) {
const eventType = events[i].type;
if (eventType === textModelEvents.TextModelEventType.ModelRawContentChanged2) {
// There is a content change event
this._centeredViewLine = -1;
this.configuration.setMaxLineNumber(this.model.getLineCount());
this._register(this.model.onDidChangeRawContent((e) => {
const eventsCollector = new ViewEventsCollector();
break;
}
}
// Update the configuration and reset the centered view line
this._centeredViewLine = -1;
this.configuration.setMaxLineNumber(this.model.getLineCount());
let hadOtherModelChange = false;
let hadModelLineChangeThatChangedLineMapping = false;
let hadOtherModelChange = false;
let hadModelLineChangeThatChangedLineMapping = false;
for (let i = 0, len = events.length; i < len; i++) {
const _e = events[i];
const type = _e.type;
const data = _e.data;
const changes = e.changes;
const versionId = e.versionId;
switch (type) {
for (let j = 0, lenJ = changes.length; j < lenJ; j++) {
const change = changes[j];
case textModelEvents.TextModelEventType.ModelRawContentChanged2: {
const e = <textModelEvents.ModelRawContentChangedEvent>data;
const changes = e.changes;
const versionId = e.versionId;
for (let j = 0, lenJ = changes.length; j < lenJ; j++) {
const change = changes[j];
switch (change.changeType) {
case textModelEvents.RawContentChangedType.Flush: {
this.lines.onModelFlushed();
eventsCollector.emit(new viewEvents.ViewFlushedEvent());
this.decorations.reset();
this.viewLayout.onFlushed(this.getLineCount());
hadOtherModelChange = true;
break;
}
case textModelEvents.RawContentChangedType.LinesDeleted: {
const linesDeletedEvent = this.lines.onModelLinesDeleted(versionId, change.fromLineNumber, change.toLineNumber);
if (linesDeletedEvent !== null) {
eventsCollector.emit(linesDeletedEvent);
this.viewLayout.onLinesDeleted(linesDeletedEvent.fromLineNumber, linesDeletedEvent.toLineNumber);
}
hadOtherModelChange = true;
break;
}
case textModelEvents.RawContentChangedType.LinesInserted: {
const linesInsertedEvent = this.lines.onModelLinesInserted(versionId, change.fromLineNumber, change.toLineNumber, change.detail.split('\n'));
if (linesInsertedEvent !== null) {
eventsCollector.emit(linesInsertedEvent);
this.viewLayout.onLinesInserted(linesInsertedEvent.fromLineNumber, linesInsertedEvent.toLineNumber);
}
hadOtherModelChange = true;
break;
}
case textModelEvents.RawContentChangedType.LineChanged: {
const [lineMappingChanged, linesChangedEvent, linesInsertedEvent, linesDeletedEvent] = this.lines.onModelLineChanged(versionId, change.lineNumber, change.detail);
hadModelLineChangeThatChangedLineMapping = lineMappingChanged;
if (linesChangedEvent) {
eventsCollector.emit(linesChangedEvent);
}
if (linesInsertedEvent) {
eventsCollector.emit(linesInsertedEvent);
this.viewLayout.onLinesInserted(linesInsertedEvent.fromLineNumber, linesInsertedEvent.toLineNumber);
}
if (linesDeletedEvent) {
eventsCollector.emit(linesDeletedEvent);
this.viewLayout.onLinesDeleted(linesDeletedEvent.fromLineNumber, linesDeletedEvent.toLineNumber);
}
break;
}
case textModelEvents.RawContentChangedType.EOLChanged: {
// Nothing to do. The new version will be accepted below
break;
}
}
}
this.lines.acceptVersionId(versionId);
break;
}
case textModelEvents.TextModelEventType.ModelTokensChanged: {
const e = <textModelEvents.IModelTokensChangedEvent>data;
let viewRanges: { fromLineNumber: number; toLineNumber: number; }[] = [];
for (let j = 0, lenJ = e.ranges.length; j < lenJ; j++) {
const modelRange = e.ranges[j];
const viewStartLineNumber = this.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelRange.fromLineNumber, 1)).lineNumber;
const viewEndLineNumber = this.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelRange.toLineNumber, this.model.getLineMaxColumn(modelRange.toLineNumber))).lineNumber;
viewRanges[j] = {
fromLineNumber: viewStartLineNumber,
toLineNumber: viewEndLineNumber
};
}
eventsCollector.emit(new viewEvents.ViewTokensChangedEvent(viewRanges));
break;
}
case textModelEvents.TextModelEventType.ModelLanguageChanged: {
// That's ok, a model tokens changed event will follow shortly
break;
}
case textModelEvents.TextModelEventType.ModelLanguageConfigurationChanged: {
eventsCollector.emit(new viewEvents.ViewLanguageConfigurationEvent());
break;
}
case textModelEvents.TextModelEventType.ModelContentChanged: {
// Ignore
break;
}
case textModelEvents.TextModelEventType.ModelOptionsChanged: {
// A tab size change causes a line mapping changed event => all view parts will repaint OK, no further event needed here
if (this.lines.setTabSize(this.model.getOptions().tabSize)) {
switch (change.changeType) {
case textModelEvents.RawContentChangedType.Flush: {
this.lines.onModelFlushed();
eventsCollector.emit(new viewEvents.ViewFlushedEvent());
eventsCollector.emit(new viewEvents.ViewLineMappingChangedEvent());
eventsCollector.emit(new viewEvents.ViewDecorationsChangedEvent());
this.decorations.onLineMappingChanged();
this.decorations.reset();
this.viewLayout.onFlushed(this.getLineCount());
hadOtherModelChange = true;
break;
}
case textModelEvents.RawContentChangedType.LinesDeleted: {
const linesDeletedEvent = this.lines.onModelLinesDeleted(versionId, change.fromLineNumber, change.toLineNumber);
if (linesDeletedEvent !== null) {
eventsCollector.emit(linesDeletedEvent);
this.viewLayout.onLinesDeleted(linesDeletedEvent.fromLineNumber, linesDeletedEvent.toLineNumber);
}
hadOtherModelChange = true;
break;
}
case textModelEvents.RawContentChangedType.LinesInserted: {
const linesInsertedEvent = this.lines.onModelLinesInserted(versionId, change.fromLineNumber, change.toLineNumber, change.detail.split('\n'));
if (linesInsertedEvent !== null) {
eventsCollector.emit(linesInsertedEvent);
this.viewLayout.onLinesInserted(linesInsertedEvent.fromLineNumber, linesInsertedEvent.toLineNumber);
}
hadOtherModelChange = true;
break;
}
case textModelEvents.RawContentChangedType.LineChanged: {
const [lineMappingChanged, linesChangedEvent, linesInsertedEvent, linesDeletedEvent] = this.lines.onModelLineChanged(versionId, change.lineNumber, change.detail);
hadModelLineChangeThatChangedLineMapping = lineMappingChanged;
if (linesChangedEvent) {
eventsCollector.emit(linesChangedEvent);
}
if (linesInsertedEvent) {
eventsCollector.emit(linesInsertedEvent);
this.viewLayout.onLinesInserted(linesInsertedEvent.fromLineNumber, linesInsertedEvent.toLineNumber);
}
if (linesDeletedEvent) {
eventsCollector.emit(linesDeletedEvent);
this.viewLayout.onLinesDeleted(linesDeletedEvent.fromLineNumber, linesDeletedEvent.toLineNumber);
}
break;
}
case textModelEvents.RawContentChangedType.EOLChanged: {
// Nothing to do. The new version will be accepted below
break;
}
break;
}
case textModelEvents.TextModelEventType.ModelDecorationsChanged: {
this.decorations.onModelDecorationsChanged();
eventsCollector.emit(new viewEvents.ViewDecorationsChangedEvent());
break;
}
case textModelEvents.TextModelEventType.ModelDispose: {
// Ignore, since the editor will take care of this and destroy the view shortly
break;
}
default:
console.info('View received unknown event: ');
console.info(type, data);
}
}
this.lines.acceptVersionId(versionId);
if (!hadOtherModelChange && hadModelLineChangeThatChangedLineMapping) {
eventsCollector.emit(new viewEvents.ViewLineMappingChangedEvent());
eventsCollector.emit(new viewEvents.ViewDecorationsChangedEvent());
this.decorations.onLineMappingChanged();
}
if (!hadOtherModelChange && hadModelLineChangeThatChangedLineMapping) {
eventsCollector.emit(new viewEvents.ViewLineMappingChangedEvent());
eventsCollector.emit(new viewEvents.ViewDecorationsChangedEvent());
this.decorations.onLineMappingChanged();
}
this._emit(eventsCollector.finalize());
}));
this._register(this.model.onDidChangeTokens((e) => {
let viewRanges: { fromLineNumber: number; toLineNumber: number; }[] = [];
for (let j = 0, lenJ = e.ranges.length; j < lenJ; j++) {
const modelRange = e.ranges[j];
const viewStartLineNumber = this.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelRange.fromLineNumber, 1)).lineNumber;
const viewEndLineNumber = this.coordinatesConverter.convertModelPositionToViewPosition(new Position(modelRange.toLineNumber, this.model.getLineMaxColumn(modelRange.toLineNumber))).lineNumber;
viewRanges[j] = {
fromLineNumber: viewStartLineNumber,
toLineNumber: viewEndLineNumber
};
}
this._emit([new viewEvents.ViewTokensChangedEvent(viewRanges)]);
}));
this._register(this.model.onDidChangeLanguageConfiguration((e) => {
this._emit([new viewEvents.ViewLanguageConfigurationEvent()]);
}));
this._register(this.model.onDidChangeOptions((e) => {
// A tab size change causes a line mapping changed event => all view parts will repaint OK, no further event needed here
if (this.lines.setTabSize(this.model.getOptions().tabSize)) {
this.decorations.onLineMappingChanged();
this.viewLayout.onFlushed(this.getLineCount());
this._emit([
new viewEvents.ViewFlushedEvent(),
new viewEvents.ViewLineMappingChangedEvent(),
new viewEvents.ViewDecorationsChangedEvent(),
]);
}
}));
this._register(this.model.onDidChangeDecorations((e) => {
this.decorations.onModelDecorationsChanged();
this._emit([new viewEvents.ViewDecorationsChangedEvent()]);
}));
}
public setHiddenAreas(ranges: Range[]): void {