ckaczor/azuredatastudio
1
0
Fork 0
mirror of https://github.com/ckaczor/azuredatastudio.git synced 2026-02-15 18:46:36 -05:00
Code Issues Packages Projects Releases Wiki Activity

Merge from master

Browse Source
This commit is contained in:
Raj Musuku
2019-02-21 17:56:04 -08:00
parent 5a146e34fa
commit 666ae11639
11482 changed files with 119352 additions and 255574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

11
src/vs/editor/common/viewModel/characterHardWrappingLineMapper.ts
View File

@@ -2,15 +2,14 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as strings from 'vs/base/common/strings';
import { PrefixSumComputer } from 'vs/editor/common/viewModel/prefixSumComputer';
import { ILineMapperFactory, ILineMapping, OutputPosition } from 'vs/editor/common/viewModel/splitLinesCollection';
import { CharCode } from 'vs/base/common/charCode';
import * as strings from 'vs/base/common/strings';
import { WrappingIndent } from 'vs/editor/common/config/editorOptions';
import { CharacterClassifier } from 'vs/editor/common/core/characterClassifier';
import { toUint32Array } from 'vs/editor/common/core/uint';
import { WrappingIndent } from 'vs/editor/common/config/editorOptions';
import { PrefixSumComputer } from 'vs/editor/common/viewModel/prefixSumComputer';
import { ILineMapperFactory, ILineMapping, OutputPosition } from 'vs/editor/common/viewModel/splitLinesCollection';
const enum CharacterClass {
NONE = 0,
@@ -75,7 +74,7 @@ export class CharacterHardWrappingLineMapperFactory implements ILineMapperFactor
return currentVisibleColumn + columnSize;
}
public createLineMapping(lineText: string, tabSize: number, breakingColumn: number, columnsForFullWidthChar: number, hardWrappingIndent: WrappingIndent): ILineMapping {
public createLineMapping(lineText: string, tabSize: number, breakingColumn: number, columnsForFullWidthChar: number, hardWrappingIndent: WrappingIndent): ILineMapping | null {
if (breakingColumn === -1) {
return null;
}

9
src/vs/editor/common/viewModel/prefixSumComputer.ts
View File

@@ -2,7 +2,6 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { toUint32 } from 'vs/editor/common/core/uint';
@@ -166,9 +165,9 @@ export class PrefixSumComputer {
let low = 0;
let high = this.values.length - 1;
let mid: number;
let midStop: number;
let midStart: number;
let mid = 0;
let midStop = 0;
let midStart = 0;
while (low <= high) {
mid = low + ((high - low) / 2) | 0;
@@ -193,7 +192,7 @@ export class PrefixSumComputerWithCache {
private readonly _actual: PrefixSumComputer;
private _cacheAccumulatedValueStart: number = 0;
private _cache: PrefixSumIndexOfResult[] = null;
private _cache: PrefixSumIndexOfResult[] | null = null;
constructor(values: Uint32Array) {
this._actual = new PrefixSumComputer(values);

182
src/vs/editor/common/viewModel/splitLinesCollection.ts
View File

@@ -2,19 +2,17 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { Position } from 'vs/editor/common/core/position';
import { Range, IRange } from 'vs/editor/common/core/range';
import { LineTokens } from 'vs/editor/common/core/lineTokens';
import { PrefixSumComputerWithCache } from 'vs/editor/common/viewModel/prefixSumComputer';
import { ViewLineData, ICoordinatesConverter, IOverviewRulerDecorations } from 'vs/editor/common/viewModel/viewModel';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { WrappingIndent } from 'vs/editor/common/config/editorOptions';
import { LineTokens } from 'vs/editor/common/core/lineTokens';
import { Position } from 'vs/editor/common/core/position';
import { IRange, Range } from 'vs/editor/common/core/range';
import { EndOfLinePreference, IActiveIndentGuideInfo, IModelDecoration, IModelDeltaDecoration, ITextModel } from 'vs/editor/common/model';
import { ModelDecorationOptions, ModelDecorationOverviewRulerOptions } from 'vs/editor/common/model/textModel';
import { ThemeColor, ITheme } from 'vs/platform/theme/common/themeService';
import { Color } from 'vs/base/common/color';
import { IModelDecoration, ITextModel, IModelDeltaDecoration, EndOfLinePreference, IActiveIndentGuideInfo } from 'vs/editor/common/model';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { PrefixSumComputerWithCache } from 'vs/editor/common/viewModel/prefixSumComputer';
import { ICoordinatesConverter, IOverviewRulerDecorations, ViewLineData } from 'vs/editor/common/viewModel/viewModel';
import { ITheme } from 'vs/platform/theme/common/themeService';
export class OutputPosition {
_outputPositionBrand: void;
@@ -35,7 +33,7 @@ export interface ILineMapping {
}
export interface ILineMapperFactory {
createLineMapping(lineText: string, tabSize: number, wrappingColumn: number, columnsForFullWidthChar: number, wrappingIndent: WrappingIndent): ILineMapping;
createLineMapping(lineText: string, tabSize: number, wrappingColumn: number, columnsForFullWidthChar: number, wrappingIndent: WrappingIndent): ILineMapping | null;
}
export interface ISimpleModel {
@@ -57,7 +55,7 @@ export interface ISplitLine {
getViewLineMinColumn(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): number;
getViewLineMaxColumn(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): number;
getViewLineData(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): ViewLineData;
getViewLinesData(model: ISimpleModel, modelLineNumber: number, fromOuputLineIndex: number, toOutputLineIndex: number, globalStartIndex: number, needed: boolean[], result: ViewLineData[]): void;
getViewLinesData(model: ISimpleModel, modelLineNumber: number, fromOuputLineIndex: number, toOutputLineIndex: number, globalStartIndex: number, needed: boolean[], result: (ViewLineData | null)[]): void;
getModelColumnOfViewPosition(outputLineIndex: number, outputColumn: number): number;
getViewPositionOfModelPosition(deltaLineNumber: number, inputColumn: number): Position;
@@ -75,9 +73,9 @@ export interface IViewModelLinesCollection {
setHiddenAreas(_ranges: Range[]): boolean;
onModelFlushed(): void;
onModelLinesDeleted(versionId: number, fromLineNumber: number, toLineNumber: number): viewEvents.ViewLinesDeletedEvent;
onModelLinesInserted(versionId: number, fromLineNumber: number, toLineNumber: number, text: string[]): viewEvents.ViewLinesInsertedEvent;
onModelLineChanged(versionId: number, lineNumber: number, newText: string): [boolean, viewEvents.ViewLinesChangedEvent, viewEvents.ViewLinesInsertedEvent, viewEvents.ViewLinesDeletedEvent];
onModelLinesDeleted(versionId: number, fromLineNumber: number, toLineNumber: number): viewEvents.ViewLinesDeletedEvent | null;
onModelLinesInserted(versionId: number, fromLineNumber: number, toLineNumber: number, text: string[]): viewEvents.ViewLinesInsertedEvent | null;
onModelLineChanged(versionId: number, lineNumber: number, newText: string): [boolean, viewEvents.ViewLinesChangedEvent | null, viewEvents.ViewLinesInsertedEvent | null, viewEvents.ViewLinesDeletedEvent | null];
acceptVersionId(versionId: number): void;
getViewLineCount(): number;
@@ -89,7 +87,7 @@ export interface IViewModelLinesCollection {
getViewLineMinColumn(viewLineNumber: number): number;
getViewLineMaxColumn(viewLineNumber: number): number;
getViewLineData(viewLineNumber: number): ViewLineData;
getViewLinesData(viewStartLineNumber: number, viewEndLineNumber: number, needed: boolean[]): ViewLineData[];
getViewLinesData(viewStartLineNumber: number, viewEndLineNumber: number, needed: boolean[]): (ViewLineData | null)[];
getAllOverviewRulerDecorations(ownerId: number, filterOutValidation: boolean, theme: ITheme): IOverviewRulerDecorations;
getDecorationsInRange(range: Range, ownerId: number, filterOutValidation: boolean): IModelDecoration[];
@@ -192,6 +190,10 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
// This is pretty bad, it means we lost track of the model...
throw new Error(`ViewModel is out of sync with Model!`);
}
if (this.lines.length !== this.model.getLineCount()) {
// This is pretty bad, it means we lost track of the model...
this._constructLines(false);
}
}
private _constructLines(resetHiddenAreas: boolean): void {
@@ -205,7 +207,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
let lineCount = linesContent.length;
let values = new Uint32Array(lineCount);
let hiddenAreas = this.hiddenAreasIds.map((areaId) => this.model.getDecorationRange(areaId)).sort(Range.compareRangesUsingStarts);
let hiddenAreas = this.hiddenAreasIds.map((areaId) => this.model.getDecorationRange(areaId)!).sort(Range.compareRangesUsingStarts);
let hiddenAreaStart = 1, hiddenAreaEnd = 0;
let hiddenAreaIdx = -1;
let nextLineNumberToUpdateHiddenArea = (hiddenAreaIdx + 1 < hiddenAreas.length) ? hiddenAreaEnd + 1 : lineCount + 2;
@@ -215,8 +217,8 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
if (lineNumber === nextLineNumberToUpdateHiddenArea) {
hiddenAreaIdx++;
hiddenAreaStart = hiddenAreas[hiddenAreaIdx].startLineNumber;
hiddenAreaEnd = hiddenAreas[hiddenAreaIdx].endLineNumber;
hiddenAreaStart = hiddenAreas[hiddenAreaIdx]!.startLineNumber;
hiddenAreaEnd = hiddenAreas[hiddenAreaIdx]!.endLineNumber;
nextLineNumberToUpdateHiddenArea = (hiddenAreaIdx + 1 < hiddenAreas.length) ? hiddenAreaEnd + 1 : lineCount + 2;
}
@@ -233,7 +235,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
public getHiddenAreas(): Range[] {
return this.hiddenAreasIds.map((decId) => {
return this.model.getDecorationRange(decId);
return this.model.getDecorationRange(decId)!;
});
}
@@ -267,7 +269,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
let newRanges = this._reduceRanges(_ranges);
// BEGIN TODO@Martin: Please stop calling this method on each model change!
let oldRanges = this.hiddenAreasIds.map((areaId) => this.model.getDecorationRange(areaId)).sort(Range.compareRangesUsingStarts);
let oldRanges = this.hiddenAreasIds.map((areaId) => this.model.getDecorationRange(areaId)!).sort(Range.compareRangesUsingStarts);
if (newRanges.length === oldRanges.length) {
let hasDifference = false;
@@ -338,7 +340,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
return true;
}
public modelPositionIsVisible(modelLineNumber: number, modelColumn: number): boolean {
public modelPositionIsVisible(modelLineNumber: number, _modelColumn: number): boolean {
if (modelLineNumber < 1 || modelLineNumber > this.lines.length) {
// invalid arguments
return false;
@@ -375,7 +377,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
this._constructLines(true);
}
public onModelLinesDeleted(versionId: number, fromLineNumber: number, toLineNumber: number): viewEvents.ViewLinesDeletedEvent {
public onModelLinesDeleted(versionId: number, fromLineNumber: number, toLineNumber: number): viewEvents.ViewLinesDeletedEvent | null {
if (versionId <= this._validModelVersionId) {
// Here we check for versionId in case the lines were reconstructed in the meantime.
// We don't want to apply stale change events on top of a newer read model state.
@@ -391,7 +393,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
return new viewEvents.ViewLinesDeletedEvent(outputFromLineNumber, outputToLineNumber);
}
public onModelLinesInserted(versionId: number, fromLineNumber: number, toLineNumber: number, text: string[]): viewEvents.ViewLinesInsertedEvent {
public onModelLinesInserted(versionId: number, fromLineNumber: number, _toLineNumber: number, text: string[]): viewEvents.ViewLinesInsertedEvent | null {
if (versionId <= this._validModelVersionId) {
// Here we check for versionId in case the lines were reconstructed in the meantime.
// We don't want to apply stale change events on top of a newer read model state.
@@ -431,7 +433,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
return new viewEvents.ViewLinesInsertedEvent(outputFromLineNumber, outputFromLineNumber + totalOutputLineCount - 1);
}
public onModelLineChanged(versionId: number, lineNumber: number, newText: string): [boolean, viewEvents.ViewLinesChangedEvent, viewEvents.ViewLinesInsertedEvent, viewEvents.ViewLinesDeletedEvent] {
public onModelLineChanged(versionId: number, lineNumber: number, newText: string): [boolean, viewEvents.ViewLinesChangedEvent | null, viewEvents.ViewLinesInsertedEvent | null, viewEvents.ViewLinesDeletedEvent | null] {
if (versionId <= this._validModelVersionId) {
// Here we check for versionId in case the lines were reconstructed in the meantime.
// We don't want to apply stale change events on top of a newer read model state.
@@ -523,7 +525,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
const result = this.model.getActiveIndentGuide(modelPosition.lineNumber, modelMinPosition.lineNumber, modelMaxPosition.lineNumber);
const viewStartPosition = this.convertModelPositionToViewPosition(result.startLineNumber, 1);
const viewEndPosition = this.convertModelPositionToViewPosition(result.endLineNumber, 1);
const viewEndPosition = this.convertModelPositionToViewPosition(result.endLineNumber, this.model.getLineMaxColumn(result.endLineNumber));
return {
startLineNumber: viewStartPosition.lineNumber,
endLineNumber: viewEndPosition.lineNumber,
@@ -545,7 +547,7 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
const modelStartLineIndex = modelStart.lineNumber - 1;
const modelEndLineIndex = modelEnd.lineNumber - 1;
let reqStart: Position = null;
let reqStart: Position | null = null;
for (let modelLineIndex = modelStartLineIndex; modelLineIndex <= modelEndLineIndex; modelLineIndex++) {
const line = this.lines[modelLineIndex];
if (line.isVisible()) {
@@ -789,11 +791,11 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
for (let i = 0, len = decorations.length; i < len; i++) {
const decoration = decorations[i];
const opts = <ModelDecorationOverviewRulerOptions>decoration.options.overviewRuler;
const lane = opts.position;
const lane = opts ? opts.position : 0;
if (lane === 0) {
continue;
}
const color = resolveColor(opts, theme);
const color = opts.getColor(theme);
const viewStartLineNumber = this._getViewLineNumberForModelPosition(decoration.range.startLineNumber, decoration.range.startColumn);
const viewEndLineNumber = this._getViewLineNumberForModelPosition(decoration.range.endLineNumber, decoration.range.endColumn);
@@ -808,14 +810,15 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
if (modelEnd.lineNumber - modelStart.lineNumber <= range.endLineNumber - range.startLineNumber) {
// most likely there are no hidden lines => fast path
return this.model.getDecorationsInRange(new Range(modelStart.lineNumber, modelStart.column, modelEnd.lineNumber, modelEnd.column), ownerId, filterOutValidation);
// fetch decorations from column 1 to cover the case of wrapped lines that have whole line decorations at column 1
return this.model.getDecorationsInRange(new Range(modelStart.lineNumber, 1, modelEnd.lineNumber, modelEnd.column), ownerId, filterOutValidation);
}
let result: IModelDecoration[] = [];
const modelStartLineIndex = modelStart.lineNumber - 1;
const modelEndLineIndex = modelEnd.lineNumber - 1;
let reqStart: Position = null;
let reqStart: Position | null = null;
for (let modelLineIndex = modelStartLineIndex; modelLineIndex <= modelEndLineIndex; modelLineIndex++) {
const line = this.lines[modelLineIndex];
if (line.isVisible()) {
@@ -838,7 +841,35 @@ export class SplitLinesCollection implements IViewModelLinesCollection {
reqStart = null;
}
return result;
result.sort((a, b) => {
const res = Range.compareRangesUsingStarts(a.range, b.range);
if (res === 0) {
if (a.id < b.id) {
return -1;
}
if (a.id > b.id) {
return 1;
}
return 0;
}
return res;
});
// Eliminate duplicate decorations that might have intersected our visible ranges multiple times
let finalResult: IModelDecoration[] = [], finalResultLen = 0;
let prevDecId: string | null = null;
for (let i = 0, len = result.length; i < len; i++) {
const dec = result[i];
const decId = dec.id;
if (prevDecId === decId) {
// skip
continue;
}
prevDecId = decId;
finalResult[finalResultLen++] = dec;
}
return finalResult;
}
}
@@ -863,23 +894,23 @@ class VisibleIdentitySplitLine implements ISplitLine {
return 1;
}
public getViewLineContent(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): string {
public getViewLineContent(model: ISimpleModel, modelLineNumber: number, _outputLineIndex: number): string {
return model.getLineContent(modelLineNumber);
}
public getViewLineLength(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): number {
public getViewLineLength(model: ISimpleModel, modelLineNumber: number, _outputLineIndex: number): number {
return model.getLineLength(modelLineNumber);
}
public getViewLineMinColumn(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): number {
public getViewLineMinColumn(model: ISimpleModel, modelLineNumber: number, _outputLineIndex: number): number {
return model.getLineMinColumn(modelLineNumber);
}
public getViewLineMaxColumn(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): number {
public getViewLineMaxColumn(model: ISimpleModel, modelLineNumber: number, _outputLineIndex: number): number {
return model.getLineMaxColumn(modelLineNumber);
}
public getViewLineData(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): ViewLineData {
public getViewLineData(model: ISimpleModel, modelLineNumber: number, _outputLineIndex: number): ViewLineData {
let lineTokens = model.getLineTokens(modelLineNumber);
let lineContent = lineTokens.getLineContent();
return new ViewLineData(
@@ -891,7 +922,7 @@ class VisibleIdentitySplitLine implements ISplitLine {
);
}
public getViewLinesData(model: ISimpleModel, modelLineNumber: number, fromOuputLineIndex: number, toOutputLineIndex: number, globalStartIndex: number, needed: boolean[], result: ViewLineData[]): void {
public getViewLinesData(model: ISimpleModel, modelLineNumber: number, _fromOuputLineIndex: number, _toOutputLineIndex: number, globalStartIndex: number, needed: boolean[], result: (ViewLineData | null)[]): void {
if (!needed[globalStartIndex]) {
result[globalStartIndex] = null;
return;
@@ -899,7 +930,7 @@ class VisibleIdentitySplitLine implements ISplitLine {
result[globalStartIndex] = this.getViewLineData(model, modelLineNumber, 0);
}
public getModelColumnOfViewPosition(outputLineIndex: number, outputColumn: number): number {
public getModelColumnOfViewPosition(_outputLineIndex: number, outputColumn: number): number {
return outputColumn;
}
@@ -907,7 +938,7 @@ class VisibleIdentitySplitLine implements ISplitLine {
return new Position(deltaLineNumber, inputColumn);
}
public getViewLineNumberOfModelPosition(deltaLineNumber: number, inputColumn: number): number {
public getViewLineNumberOfModelPosition(deltaLineNumber: number, _inputColumn: number): number {
return deltaLineNumber;
}
}
@@ -933,39 +964,39 @@ class InvisibleIdentitySplitLine implements ISplitLine {
return 0;
}
public getViewLineContent(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): string {
public getViewLineContent(_model: ISimpleModel, _modelLineNumber: number, _outputLineIndex: number): string {
throw new Error('Not supported');
}
public getViewLineLength(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): number {
public getViewLineLength(_model: ISimpleModel, _modelLineNumber: number, _outputLineIndex: number): number {
throw new Error('Not supported');
}
public getViewLineMinColumn(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): number {
public getViewLineMinColumn(_model: ISimpleModel, _modelLineNumber: number, _outputLineIndex: number): number {
throw new Error('Not supported');
}
public getViewLineMaxColumn(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): number {
public getViewLineMaxColumn(_model: ISimpleModel, _modelLineNumber: number, _outputLineIndex: number): number {
throw new Error('Not supported');
}
public getViewLineData(model: ISimpleModel, modelLineNumber: number, outputLineIndex: number): ViewLineData {
public getViewLineData(_model: ISimpleModel, _modelLineNumber: number, _outputLineIndex: number): ViewLineData {
throw new Error('Not supported');
}
public getViewLinesData(model: ISimpleModel, modelLineNumber: number, fromOuputLineIndex: number, toOutputLineIndex: number, globalStartIndex: number, needed: boolean[], result: ViewLineData[]): void {
public getViewLinesData(_model: ISimpleModel, _modelLineNumber: number, _fromOuputLineIndex: number, _toOutputLineIndex: number, _globalStartIndex: number, _needed: boolean[], _result: ViewLineData[]): void {
throw new Error('Not supported');
}
public getModelColumnOfViewPosition(outputLineIndex: number, outputColumn: number): number {
public getModelColumnOfViewPosition(_outputLineIndex: number, _outputColumn: number): number {
throw new Error('Not supported');
}
public getViewPositionOfModelPosition(deltaLineNumber: number, inputColumn: number): Position {
public getViewPositionOfModelPosition(_deltaLineNumber: number, _inputColumn: number): Position {
throw new Error('Not supported');
}
public getViewLineNumberOfModelPosition(deltaLineNumber: number, inputColumn: number): number {
public getViewLineNumberOfModelPosition(_deltaLineNumber: number, _inputColumn: number): number {
throw new Error('Not supported');
}
}
@@ -1049,7 +1080,7 @@ export class SplitLine implements ISplitLine {
return r;
}
public getViewLineMinColumn(model: ITextModel, modelLineNumber: number, outputLineIndex: number): number {
public getViewLineMinColumn(_model: ITextModel, _modelLineNumber: number, outputLineIndex: number): number {
if (!this._isVisible) {
throw new Error('Not supported');
}
@@ -1105,7 +1136,7 @@ export class SplitLine implements ISplitLine {
);
}
public getViewLinesData(model: ITextModel, modelLineNumber: number, fromOuputLineIndex: number, toOutputLineIndex: number, globalStartIndex: number, needed: boolean[], result: ViewLineData[]): void {
public getViewLinesData(model: ITextModel, modelLineNumber: number, fromOuputLineIndex: number, toOutputLineIndex: number, globalStartIndex: number, needed: boolean[], result: (ViewLineData | null)[]): void {
if (!this._isVisible) {
throw new Error('Not supported');
}
@@ -1199,11 +1230,11 @@ export class IdentityCoordinatesConverter implements ICoordinatesConverter {
return this._validRange(viewRange);
}
public validateViewPosition(viewPosition: Position, expectedModelPosition: Position): Position {
public validateViewPosition(_viewPosition: Position, expectedModelPosition: Position): Position {
return this._validPosition(expectedModelPosition);
}
public validateViewRange(viewRange: Range, expectedModelRange: Range): Range {
public validateViewRange(_viewRange: Range, expectedModelRange: Range): Range {
return this._validRange(expectedModelRange);
}
@@ -1251,40 +1282,40 @@ export class IdentityLinesCollection implements IViewModelLinesCollection {
return false;
}
public setTabSize(newTabSize: number): boolean {
public setTabSize(_newTabSize: number): boolean {
return false;
}
public setWrappingSettings(wrappingIndent: WrappingIndent, wrappingColumn: number, columnsForFullWidthChar: number): boolean {
public setWrappingSettings(_wrappingIndent: WrappingIndent, _wrappingColumn: number, _columnsForFullWidthChar: number): boolean {
return false;
}
public onModelFlushed(): void {
}
public onModelLinesDeleted(versionId: number, fromLineNumber: number, toLineNumber: number): viewEvents.ViewLinesDeletedEvent {
public onModelLinesDeleted(_versionId: number, fromLineNumber: number, toLineNumber: number): viewEvents.ViewLinesDeletedEvent | null {
return new viewEvents.ViewLinesDeletedEvent(fromLineNumber, toLineNumber);
}
public onModelLinesInserted(versionId: number, fromLineNumber: number, toLineNumber: number, text: string[]): viewEvents.ViewLinesInsertedEvent {
public onModelLinesInserted(_versionId: number, fromLineNumber: number, toLineNumber: number, _text: string[]): viewEvents.ViewLinesInsertedEvent | null {
return new viewEvents.ViewLinesInsertedEvent(fromLineNumber, toLineNumber);
}
public onModelLineChanged(versionId: number, lineNumber: number, newText: string): [boolean, viewEvents.ViewLinesChangedEvent, viewEvents.ViewLinesInsertedEvent, viewEvents.ViewLinesDeletedEvent] {
public onModelLineChanged(_versionId: number, lineNumber: number, _newText: string): [boolean, viewEvents.ViewLinesChangedEvent | null, viewEvents.ViewLinesInsertedEvent | null, viewEvents.ViewLinesDeletedEvent | null] {
return [false, new viewEvents.ViewLinesChangedEvent(lineNumber, lineNumber), null, null];
}
public acceptVersionId(versionId: number): void {
public acceptVersionId(_versionId: number): void {
}
public getViewLineCount(): number {
return this.model.getLineCount();
}
public warmUpLookupCache(viewStartLineNumber: number, viewEndLineNumber: number): void {
public warmUpLookupCache(_viewStartLineNumber: number, _viewEndLineNumber: number): void {
}
public getActiveIndentGuide(viewLineNumber: number, minLineNumber: number, maxLineNumber: number): IActiveIndentGuideInfo {
public getActiveIndentGuide(viewLineNumber: number, _minLineNumber: number, _maxLineNumber: number): IActiveIndentGuideInfo {
return {
startLineNumber: viewLineNumber,
endLineNumber: viewLineNumber,
@@ -1329,12 +1360,12 @@ export class IdentityLinesCollection implements IViewModelLinesCollection {
);
}
public getViewLinesData(viewStartLineNumber: number, viewEndLineNumber: number, needed: boolean[]): ViewLineData[] {
public getViewLinesData(viewStartLineNumber: number, viewEndLineNumber: number, needed: boolean[]): (ViewLineData | null)[] {
const lineCount = this.model.getLineCount();
viewStartLineNumber = Math.min(Math.max(1, viewStartLineNumber), lineCount);
viewEndLineNumber = Math.min(Math.max(1, viewEndLineNumber), lineCount);
let result: ViewLineData[] = [];
let result: (ViewLineData | null)[] = [];
for (let lineNumber = viewStartLineNumber; lineNumber <= viewEndLineNumber; lineNumber++) {
let idx = lineNumber - viewStartLineNumber;
if (!needed[idx]) {
@@ -1352,11 +1383,11 @@ export class IdentityLinesCollection implements IViewModelLinesCollection {
for (let i = 0, len = decorations.length; i < len; i++) {
const decoration = decorations[i];
const opts = <ModelDecorationOverviewRulerOptions>decoration.options.overviewRuler;
const lane = opts.position;
const lane = opts ? opts.position : 0;
if (lane === 0) {
continue;
}
const color = resolveColor(opts, theme);
const color = opts.getColor(theme);
const viewStartLineNumber = decoration.range.startLineNumber;
const viewEndLineNumber = decoration.range.endLineNumber;
@@ -1398,24 +1429,3 @@ class OverviewRulerDecorations {
}
}
}
function resolveColor(opts: ModelDecorationOverviewRulerOptions, theme: ITheme): string {
if (!opts._resolvedColor) {
const themeType = theme.type;
const color = (themeType === 'dark' ? opts.darkColor : themeType === 'light' ? opts.color : opts.hcColor);
opts._resolvedColor = resolveRulerColor(color, theme);
}
return opts._resolvedColor;
}
function resolveRulerColor(color: string | ThemeColor, theme: ITheme): string {
if (typeof color === 'string') {
return color;
}
let c = color ? theme.getColor(color.id) : null;
if (!c) {
c = Color.transparent;
}
return c.toString();
}

3
src/vs/editor/common/viewModel/viewEventHandler.ts
View File

@@ -2,10 +2,9 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { Disposable } from 'vs/base/common/lifecycle';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
export class ViewEventHandler extends Disposable {

26
src/vs/editor/common/viewModel/viewModel.ts
View File

@@ -2,20 +2,19 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { INewScrollPosition } from 'vs/editor/common/editorCommon';
import { EndOfLinePreference, IModelDecorationOptions, IActiveIndentGuideInfo } from 'vs/editor/common/model';
import { IViewLineTokens } from 'vs/editor/common/core/lineTokens';
import { Position, IPosition } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import { IViewEventListener } from 'vs/editor/common/view/viewEvents';
import { IDisposable } from 'vs/base/common/lifecycle';
import { Scrollable, IScrollPosition } from 'vs/base/common/scrollable';
import { IScrollPosition, Scrollable } from 'vs/base/common/scrollable';
import * as strings from 'vs/base/common/strings';
import { IViewLineTokens } from 'vs/editor/common/core/lineTokens';
import { IPosition, Position } from 'vs/editor/common/core/position';
import { IRange, Range } from 'vs/editor/common/core/range';
import { INewScrollPosition } from 'vs/editor/common/editorCommon';
import { EndOfLinePreference, IActiveIndentGuideInfo, IModelDecorationOptions } from 'vs/editor/common/model';
import { IViewEventListener } from 'vs/editor/common/view/viewEvents';
import { IPartialViewLinesViewportData } from 'vs/editor/common/viewLayout/viewLinesViewportData';
import { IEditorWhitespace } from 'vs/editor/common/viewLayout/whitespaceComputer';
import { ITheme } from 'vs/platform/theme/common/themeService';
import * as strings from 'vs/base/common/strings';
export interface IViewWhitespaceViewportData {
readonly id: number;
@@ -67,7 +66,7 @@ export interface IViewLayout {
isAfterLines(verticalOffset: number): boolean;
getLineNumberAtVerticalOffset(verticalOffset: number): number;
getVerticalOffsetForLineNumber(lineNumber: number): number;
getWhitespaceAtVerticalOffset(verticalOffset: number): IViewWhitespaceViewportData;
getWhitespaceAtVerticalOffset(verticalOffset: number): IViewWhitespaceViewportData | null;
// --------------- Begin vertical whitespace management
@@ -145,20 +144,21 @@ export interface IViewModel {
getModelLineMaxColumn(modelLineNumber: number): number;
validateModelPosition(modelPosition: IPosition): Position;
validateModelRange(range: IRange): Range;
deduceModelPositionRelativeToViewPosition(viewAnchorPosition: Position, deltaOffset: number, lineFeedCnt: number): Position;
getEOL(): string;
getPlainTextToCopy(ranges: Range[], emptySelectionClipboard: boolean, forceCRLF: boolean): string | string[];
getHTMLToCopy(ranges: Range[], emptySelectionClipboard: boolean): string;
getHTMLToCopy(ranges: Range[], emptySelectionClipboard: boolean): string | null;
}
export class MinimapLinesRenderingData {
public readonly tabSize: number;
public readonly data: ViewLineData[];
public readonly data: (ViewLineData | null)[];
constructor(
tabSize: number,
data: ViewLineData[]
data: (ViewLineData | null)[]
) {
this.tabSize = tabSize;
this.data = data;

15
src/vs/editor/common/viewModel/viewModelDecorations.ts
View File

@@ -2,15 +2,14 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
import { IDisposable } from 'vs/base/common/lifecycle';
import { Range } from 'vs/editor/common/core/range';
import { Position } from 'vs/editor/common/core/position';
import { Range } from 'vs/editor/common/core/range';
import * as editorCommon from 'vs/editor/common/editorCommon';
import { InlineDecoration, ViewModelDecoration, ICoordinatesConverter, InlineDecorationType } from 'vs/editor/common/viewModel/viewModel';
import { IModelDecoration, ITextModel } from 'vs/editor/common/model';
import { IViewModelLinesCollection } from 'vs/editor/common/viewModel/splitLinesCollection';
import { ITextModel, IModelDecoration } from 'vs/editor/common/model';
import { ICoordinatesConverter, InlineDecoration, InlineDecorationType, ViewModelDecoration } from 'vs/editor/common/viewModel/viewModel';
export interface IDecorationsViewportData {
/**
@@ -33,8 +32,8 @@ export class ViewModelDecorations implements IDisposable {
private _decorationsCache: { [decorationId: string]: ViewModelDecoration; };
private _cachedModelDecorationsResolver: IDecorationsViewportData;
private _cachedModelDecorationsResolverViewRange: Range;
private _cachedModelDecorationsResolver: IDecorationsViewportData | null;
private _cachedModelDecorationsResolverViewRange: Range | null;
constructor(editorId: number, model: ITextModel, configuration: editorCommon.IConfiguration, linesCollection: IViewModelLinesCollection, coordinatesConverter: ICoordinatesConverter) {
this.editorId = editorId;
@@ -52,7 +51,7 @@ export class ViewModelDecorations implements IDisposable {
}
public dispose(): void {
this._decorationsCache = null;
this._decorationsCache = Object.create(null);
this._clearCachedModelDecorationsResolver();
}
@@ -100,7 +99,7 @@ export class ViewModelDecorations implements IDisposable {
this._cachedModelDecorationsResolver = this._getDecorationsViewportData(viewRange);
this._cachedModelDecorationsResolverViewRange = viewRange;
}
return this._cachedModelDecorationsResolver;
return this._cachedModelDecorationsResolver!;
}
private _getDecorationsViewportData(viewportRange: Range): IDecorationsViewportData {

71
src/vs/editor/common/viewModel/viewModelImpl.ts
View File

@@ -2,28 +2,27 @@
* Copyright (c) Microsoft Corporation. All rights reserved.
* Licensed under the Source EULA. See License.txt in the project root for license information.
*--------------------------------------------------------------------------------------------*/
'use strict';
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';
import * as editorCommon from 'vs/editor/common/editorCommon';
import { TokenizationRegistry, ColorId, LanguageId } from 'vs/editor/common/modes';
import { tokenizeLineToHTML } from 'vs/editor/common/modes/textToHtmlTokenizer';
import { ViewModelDecorations } from 'vs/editor/common/viewModel/viewModelDecorations';
import { MinimapLinesRenderingData, ViewLineRenderingData, ViewModelDecoration, IViewModel, ICoordinatesConverter, IOverviewRulerDecorations, ViewLineData } from 'vs/editor/common/viewModel/viewModel';
import { SplitLinesCollection, IViewModelLinesCollection, IdentityLinesCollection } from 'vs/editor/common/viewModel/splitLinesCollection';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { MinimapTokensColorTracker } from 'vs/editor/common/view/minimapCharRenderer';
import * as textModelEvents from 'vs/editor/common/model/textModelEvents';
import { IConfigurationChangedEvent } from 'vs/editor/common/config/editorOptions';
import { CharacterHardWrappingLineMapperFactory } from 'vs/editor/common/viewModel/characterHardWrappingLineMapper';
import { ViewLayout } from 'vs/editor/common/viewLayout/viewLayout';
import { Color } from 'vs/base/common/color';
import { IDisposable } from 'vs/base/common/lifecycle';
import { ITheme } from 'vs/platform/theme/common/themeService';
import * as strings from 'vs/base/common/strings';
import { IConfigurationChangedEvent } from 'vs/editor/common/config/editorOptions';
import { IPosition, Position } from 'vs/editor/common/core/position';
import { IRange, Range } from 'vs/editor/common/core/range';
import * as editorCommon from 'vs/editor/common/editorCommon';
import { EndOfLinePreference, IActiveIndentGuideInfo, ITextModel, TrackedRangeStickiness } from 'vs/editor/common/model';
import { ModelDecorationOverviewRulerOptions } from 'vs/editor/common/model/textModel';
import { ITextModel, EndOfLinePreference, TrackedRangeStickiness, IActiveIndentGuideInfo } from 'vs/editor/common/model';
import * as textModelEvents from 'vs/editor/common/model/textModelEvents';
import { ColorId, LanguageId, TokenizationRegistry } from 'vs/editor/common/modes';
import { tokenizeLineToHTML } from 'vs/editor/common/modes/textToHtmlTokenizer';
import { MinimapTokensColorTracker } from 'vs/editor/common/view/minimapCharRenderer';
import * as viewEvents from 'vs/editor/common/view/viewEvents';
import { ViewLayout } from 'vs/editor/common/viewLayout/viewLayout';
import { CharacterHardWrappingLineMapperFactory } from 'vs/editor/common/viewModel/characterHardWrappingLineMapper';
import { IViewModelLinesCollection, IdentityLinesCollection, SplitLinesCollection } from 'vs/editor/common/viewModel/splitLinesCollection';
import { ICoordinatesConverter, IOverviewRulerDecorations, IViewModel, MinimapLinesRenderingData, ViewLineData, ViewLineRenderingData, ViewModelDecoration } from 'vs/editor/common/viewModel/viewModel';
import { ViewModelDecorations } from 'vs/editor/common/viewModel/viewModelDecorations';
import { ITheme } from 'vs/platform/theme/common/themeService';
const USE_IDENTITY_LINES_COLLECTION = true;
@@ -34,8 +33,8 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
private readonly model: ITextModel;
private hasFocus: boolean;
private viewportStartLine: number;
private viewportStartLineTrackedRange: string;
private viewportStartLineTop: number;
private viewportStartLineTrackedRange: string | null;
private viewportStartLineDelta: number;
private readonly lines: IViewModelLinesCollection;
public readonly coordinatesConverter: ICoordinatesConverter;
public readonly viewLayout: ViewLayout;
@@ -51,7 +50,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
this.hasFocus = false;
this.viewportStartLine = -1;
this.viewportStartLineTrackedRange = null;
this.viewportStartLineTop = 0;
this.viewportStartLineDelta = 0;
if (USE_IDENTITY_LINES_COLLECTION && this.model.isTooLargeForTokenization()) {
@@ -128,7 +127,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
private _onConfigurationChanged(eventsCollector: viewEvents.ViewEventsCollector, e: IConfigurationChangedEvent): void {
// We might need to restore the current centered view range, so save it (if available)
let previousViewportStartModelPosition: Position = null;
let previousViewportStartModelPosition: Position | null = null;
if (this.viewportStartLine !== -1) {
let previousViewportStartViewPosition = new Position(this.viewportStartLine, this.getLineMinColumn(this.viewportStartLine));
previousViewportStartModelPosition = this.coordinatesConverter.convertViewPositionToModelPosition(previousViewportStartViewPosition);
@@ -162,7 +161,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
if (restorePreviousViewportStart && previousViewportStartModelPosition) {
const viewPosition = this.coordinatesConverter.convertModelPositionToViewPosition(previousViewportStartModelPosition);
const viewPositionTop = this.viewLayout.getVerticalOffsetForLineNumber(viewPosition.lineNumber);
this.viewLayout.deltaScrollNow(0, viewPositionTop - this.viewportStartLineTop);
this.viewLayout.setScrollPositionNow({ scrollTop: viewPositionTop + this.viewportStartLineDelta });
}
}
@@ -252,7 +251,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
if (modelRange) {
const viewPosition = this.coordinatesConverter.convertModelPositionToViewPosition(modelRange.getStartPosition());
const viewPositionTop = this.viewLayout.getVerticalOffsetForLineNumber(viewPosition.lineNumber);
this.viewLayout.deltaScrollNow(0, viewPositionTop - this.viewportStartLineTop);
this.viewLayout.setScrollPositionNow({ scrollTop: viewPositionTop + this.viewportStartLineDelta });
}
}
}));
@@ -429,7 +428,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
private _reduceRestoreStateCompatibility(state: editorCommon.IViewState): { scrollLeft: number; scrollTop: number; } {
return {
scrollLeft: state.scrollLeft,
scrollTop: state.scrollTopWithoutViewZones
scrollTop: state.scrollTopWithoutViewZones!
};
}
@@ -450,7 +449,9 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
this.viewportStartLine = startLineNumber;
let position = this.coordinatesConverter.convertViewPositionToModelPosition(new Position(startLineNumber, this.getLineMinColumn(startLineNumber)));
this.viewportStartLineTrackedRange = this.model._setTrackedRange(this.viewportStartLineTrackedRange, new Range(position.lineNumber, position.column, position.lineNumber, position.column), TrackedRangeStickiness.NeverGrowsWhenTypingAtEdges);
this.viewportStartLineTop = this.viewLayout.getVerticalOffsetForLineNumber(startLineNumber);
const viewportStartLineTop = this.viewLayout.getVerticalOffsetForLineNumber(startLineNumber);
const scrollTop = this.viewLayout.getCurrentScrollTop();
this.viewportStartLineDelta = scrollTop - viewportStartLineTop;
}
public getActiveIndentGuide(lineNumber: number, minLineNumber: number, maxLineNumber: number): IActiveIndentGuideInfo {
@@ -539,7 +540,9 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
for (let i = 0, len = decorations.length; i < len; i++) {
const decoration = decorations[i];
const opts = <ModelDecorationOverviewRulerOptions>decoration.options.overviewRuler;
opts._resolvedColor = null;
if (opts) {
opts.invalidateCachedColor();
}
}
}
@@ -556,6 +559,10 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
return this.model.validatePosition(position);
}
public validateModelRange(range: IRange): Range {
return this.model.validateRange(range);
}
public deduceModelPositionRelativeToViewPosition(viewAnchorPosition: Position, deltaOffset: number, lineFeedCnt: number): Position {
const modelAnchor = this.coordinatesConverter.convertViewPositionToModelPosition(viewAnchorPosition);
if (this.model.getEOL().length === 2) {
@@ -610,7 +617,7 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
return result.length === 1 ? result[0] : result;
}
public getHTMLToCopy(viewRanges: Range[], emptySelectionClipboard: boolean): string {
public getHTMLToCopy(viewRanges: Range[], emptySelectionClipboard: boolean): string | null {
if (this.model.getLanguageIdentifier().id === LanguageId.PlainText) {
return null;
}
@@ -676,9 +683,11 @@ export class ViewModel extends viewEvents.ViewEventEmitter implements IViewModel
private _getColorMap(): string[] {
let colorMap = TokenizationRegistry.getColorMap();
let result: string[] = [null];
for (let i = 1, len = colorMap.length; i < len; i++) {
result[i] = Color.Format.CSS.formatHex(colorMap[i]);
let result: string[] = ['#000000'];
if (colorMap) {
for (let i = 1, len = colorMap.length; i < len; i++) {
result[i] = Color.Format.CSS.formatHex(colorMap[i]);
}
}
return result;
}