TypeScript WhitespaceComputer.getHeightForWhitespaceIndex方法代码示例

	/**
	 * Get a list of whitespaces that are positioned between `verticalOffset1` and `verticalOffset2`.
	 *
	 * @param verticalOffset1 The beginning of the viewport.
	 * @param verticalOffset2 The end of the viewport.
	 * @return An array with all the whitespaces in the viewport. If no whitespace is in viewport, the array is empty.
	 */
	public getWhitespaceViewportData(verticalOffset1: number, verticalOffset2: number): IViewWhitespaceViewportData[] {
		verticalOffset1 = verticalOffset1 | 0;
		verticalOffset2 = verticalOffset2 | 0;

		let startIndex = this.getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset1);
		let endIndex = this._whitespaces.getCount() - 1;

		if (startIndex < 0) {
			return [];
		}

		let result: IViewWhitespaceViewportData[] = [];
		for (let i = startIndex; i <= endIndex; i++) {
			let top = this.getVerticalOffsetForWhitespaceIndex(i);
			let height = this._whitespaces.getHeightForWhitespaceIndex(i);
			if (top >= verticalOffset2) {
				break;
			}

			result.push({
				id: this._whitespaces.getIdForWhitespaceIndex(i),
				afterLineNumber: this._whitespaces.getAfterLineNumberForWhitespaceIndex(i),
				verticalOffset: top,
				height: height
			});
		}

		return result;
	}

	/**
	 * Get exactly the whitespace that is layouted at `verticalOffset`.
	 *
	 * @param verticalOffset The vertical offset.
	 * @return Precisely the whitespace that is layouted at `verticaloffset` or null.
	 */
	public getWhitespaceAtVerticalOffset(verticalOffset: number): IViewWhitespaceViewportData | null {
		verticalOffset = verticalOffset | 0;

		let candidateIndex = this.getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset);

		if (candidateIndex < 0) {
			return null;
		}

		if (candidateIndex >= this._whitespaces.getCount()) {
			return null;
		}

		let candidateTop = this.getVerticalOffsetForWhitespaceIndex(candidateIndex);

		if (candidateTop > verticalOffset) {
			return null;
		}

		let candidateHeight = this._whitespaces.getHeightForWhitespaceIndex(candidateIndex);
		let candidateId = this._whitespaces.getIdForWhitespaceIndex(candidateIndex);
		let candidateAfterLineNumber = this._whitespaces.getAfterLineNumberForWhitespaceIndex(candidateIndex);

		return {
			id: candidateId,
			afterLineNumber: candidateAfterLineNumber,
			verticalOffset: candidateTop,
			height: candidateHeight
		};
	}

	/**
	 * Get a list of whitespaces that are positioned between `verticalOffset1` and `verticalOffset2`.
	 *
	 * @param verticalOffset1 The beginning of the viewport.
	 * @param verticalOffset2 The end of the viewport.
	 * @param deviceLineHeight The height, in pixels, for one rendered line.
	 * @return An array with all the whitespaces in the viewport. If no whitespace is in viewport, the array is empty.
	 */
	public getWhitespaceViewportData(verticalOffset1:number, verticalOffset2:number, deviceLineHeight:number): EditorCommon.IViewWhitespaceViewportData[] {

		var startIndex = this.getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset1, deviceLineHeight);
		var endIndex = this.whitespaces.getCount() - 1;

		if (startIndex < 0) {
			return [];
		}

		var result: EditorCommon.IViewWhitespaceViewportData[] = [],
			i:number,
			top:number,
			height:number;

		for (i = startIndex; i <= endIndex; i++) {
			top = this.getVerticalOffsetForWhitespaceIndex(i, deviceLineHeight);
			height = this.whitespaces.getHeightForWhitespaceIndex(i);
			if (top >= verticalOffset2) {
				break;
			}

			result.push({
				id: this.whitespaces.getIdForWhitespaceIndex(i),
				afterLineNumber: this.whitespaces.getAfterLineNumberForWhitespaceIndex(i),
				verticalOffset: top,
				height: height
			});
		}

		return result;
	}

	/**
	 * Get exactly the whitespace that is layouted at `verticalOffset`.
	 *
	 * @param verticalOffset The vertical offset.
	 * @param deviceLineHeight The height, in pixels, for one rendered line.
	 * @return Precisely the whitespace that is layouted at `verticaloffset` or null.
	 */
	public getWhitespaceAtVerticalOffset(verticalOffset:number, deviceLineHeight:number): EditorCommon.IViewWhitespaceViewportData {

		var candidateIndex = this.getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset, deviceLineHeight);

		if (candidateIndex < 0) {
			return null;
		}

		if (candidateIndex >= this.whitespaces.getCount()) {
			return null;
		}

		var candidateTop = this.getVerticalOffsetForWhitespaceIndex(candidateIndex, deviceLineHeight);

		if (candidateTop > verticalOffset) {
			return null;
		}

		var candidateHeight = this.whitespaces.getHeightForWhitespaceIndex(candidateIndex);
		var candidateId = this.whitespaces.getIdForWhitespaceIndex(candidateIndex);
		var candidateAfterLineNumber = this.whitespaces.getAfterLineNumberForWhitespaceIndex(candidateIndex);

		return {
			id: candidateId,
			afterLineNumber: candidateAfterLineNumber,
			verticalOffset: candidateTop,
			height: candidateHeight
		};
	}

	public getWhitespaceIndexAtOrAfterVerticallOffset(verticalOffset:number, deviceLineHeight:number): number {
		verticalOffset = verticalOffset|0;
		deviceLineHeight = deviceLineHeight|0;

		let midWhitespaceIndex:number,
			minWhitespaceIndex = 0,
			maxWhitespaceIndex = this.whitespaces.getCount() - 1,
			midWhitespaceVerticalOffset:number,
			midWhitespaceHeight:number;

		if (maxWhitespaceIndex < 0) {
			return -1;
		}

		// Special case: nothing to be found
		let maxWhitespaceVerticalOffset = this.getVerticalOffsetForWhitespaceIndex(maxWhitespaceIndex, deviceLineHeight);
		let maxWhitespaceHeight = this.whitespaces.getHeightForWhitespaceIndex(maxWhitespaceIndex);
		if (verticalOffset >= maxWhitespaceVerticalOffset + maxWhitespaceHeight) {
			return -1;
		}

		while (minWhitespaceIndex < maxWhitespaceIndex) {
			midWhitespaceIndex = Math.floor((minWhitespaceIndex + maxWhitespaceIndex) / 2);

			midWhitespaceVerticalOffset = this.getVerticalOffsetForWhitespaceIndex(midWhitespaceIndex, deviceLineHeight);
			midWhitespaceHeight = this.whitespaces.getHeightForWhitespaceIndex(midWhitespaceIndex);

			if (verticalOffset >= midWhitespaceVerticalOffset + midWhitespaceHeight) {
				// vertical offset is after whitespace
				minWhitespaceIndex = midWhitespaceIndex + 1;
			} else if (verticalOffset >= midWhitespaceVerticalOffset) {
				// Hit
				return midWhitespaceIndex;
			} else {
				// vertical offset is before whitespace, but midWhitespaceIndex might still be what we're searching for
				maxWhitespaceIndex = midWhitespaceIndex;
			}
		}
		return minWhitespaceIndex;
	}

	test('WhitespaceComputer', () => {

		var whitespaceComputer = new WhitespaceComputer();

		// Insert a whitespace after line number 2, of height 10
		var a = whitespaceComputer.insertWhitespace(2, 0, 10);
		// whitespaces: a(2, 10)
		assert.equal(whitespaceComputer.getCount(), 1);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 2);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(0), 10);
		assert.equal(whitespaceComputer.getAccumulatedHeight(0), 10);
		assert.equal(whitespaceComputer.getTotalHeight(), 10);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(1), 0);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(2), 0);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(3), 10);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(4), 10);

		// Insert a whitespace again after line number 2, of height 20
		var b = whitespaceComputer.insertWhitespace(2, 0, 20);
		// whitespaces: a(2, 10), b(2, 20)
		assert.equal(whitespaceComputer.getCount(), 2);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 2);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(0), 10);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(1), 2);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(1), 20);
		assert.equal(whitespaceComputer.getAccumulatedHeight(0), 10);
		assert.equal(whitespaceComputer.getAccumulatedHeight(1), 30);
		assert.equal(whitespaceComputer.getTotalHeight(), 30);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(1), 0);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(2), 0);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(3), 30);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(4), 30);

		// Change last inserted whitespace height to 30
		whitespaceComputer.changeWhitespaceHeight(b, 30);
		// whitespaces: a(2, 10), b(2, 30)
		assert.equal(whitespaceComputer.getCount(), 2);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 2);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(0), 10);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(1), 2);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(1), 30);
		assert.equal(whitespaceComputer.getAccumulatedHeight(0), 10);
		assert.equal(whitespaceComputer.getAccumulatedHeight(1), 40);
		assert.equal(whitespaceComputer.getTotalHeight(), 40);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(1), 0);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(2), 0);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(3), 40);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(4), 40);

		// Remove last inserted whitespace
		whitespaceComputer.removeWhitespace(b);
		// whitespaces: a(2, 10)
		assert.equal(whitespaceComputer.getCount(), 1);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 2);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(0), 10);
		assert.equal(whitespaceComputer.getAccumulatedHeight(0), 10);
		assert.equal(whitespaceComputer.getTotalHeight(), 10);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(1), 0);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(2), 0);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(3), 10);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(4), 10);

		// Add a whitespace before the first line of height 50
		b = whitespaceComputer.insertWhitespace(0, 0, 50);
		// whitespaces: b(0, 50), a(2, 10)
		assert.equal(whitespaceComputer.getCount(), 2);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 0);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(0), 50);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(1), 2);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(1), 10);
		assert.equal(whitespaceComputer.getAccumulatedHeight(0), 50);
		assert.equal(whitespaceComputer.getAccumulatedHeight(1), 60);
		assert.equal(whitespaceComputer.getTotalHeight(), 60);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(1), 50);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(2), 50);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(3), 60);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(4), 60);

		// Add a whitespace after line 4 of height 20
		whitespaceComputer.insertWhitespace(4, 0, 20);
		// whitespaces: b(0, 50), a(2, 10), c(4, 20)
		assert.equal(whitespaceComputer.getCount(), 3);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(0), 0);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(0), 50);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(1), 2);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(1), 10);
		assert.equal(whitespaceComputer.getAfterLineNumberForWhitespaceIndex(2), 4);
		assert.equal(whitespaceComputer.getHeightForWhitespaceIndex(2), 20);
		assert.equal(whitespaceComputer.getAccumulatedHeight(0), 50);
		assert.equal(whitespaceComputer.getAccumulatedHeight(1), 60);
		assert.equal(whitespaceComputer.getAccumulatedHeight(2), 80);
		assert.equal(whitespaceComputer.getTotalHeight(), 80);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(1), 50);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(2), 50);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(3), 60);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(4), 60);
		assert.equal(whitespaceComputer.getAccumulatedHeightBeforeLineNumber(5), 80);

		// Add a whitespace after line 3 of height 30
		whitespaceComputer.insertWhitespace(3, 0, 30);
//.........这里部分代码省略.........

	/**
	 * Get all the lines and their relative vertical offsets that are positioned between `verticalOffset1` and `verticalOffset2`.
	 *
	 * @param verticalOffset1 The beginning of the viewport.
	 * @param verticalOffset2 The end of the viewport.
	 * @param deviceLineHeight The height, in pixels, for one rendered line.
	 * @return A structure describing the lines positioned between `verticalOffset1` and `verticalOffset2`.
	 */
	public getLinesViewportData(verticalOffset1:number, verticalOffset2:number, deviceLineHeight:number): IViewLinesViewportData {
		// Find first line number
		// We don't live in a perfect world, so the line number might start before or after verticalOffset1
		var startLineNumber = this.getLineNumberAtOrAfterVerticalOffset(verticalOffset1, deviceLineHeight);

		var endLineNumber = this.linesCount,
			startLineNumberVerticalOffset = this.getVerticalOffsetForLineNumber(startLineNumber, deviceLineHeight);

		// Also keep track of what whitespace we've got
		var whitespaceIndex = this.whitespaces.getFirstWhitespaceIndexAfterLineNumber(startLineNumber),
			whitespaceCount = this.whitespaces.getCount(),
			currentWhitespaceHeight: number,
			currentWhitespaceAfterLineNumber: number;

		if (whitespaceIndex === -1) {
			whitespaceIndex = whitespaceCount;
			currentWhitespaceAfterLineNumber = endLineNumber + 1;
		} else {
			currentWhitespaceAfterLineNumber = this.whitespaces.getAfterLineNumberForWhitespaceIndex(whitespaceIndex);
			currentWhitespaceHeight = this.whitespaces.getHeightForWhitespaceIndex(whitespaceIndex);
		}

		var currentVerticalOffset = startLineNumberVerticalOffset;
		var currentLineRelativeOffset = currentVerticalOffset;

		// IE (all versions) cannot handle units above about 1,533,908 px, so every 500k pixels bring numbers down
		var STEP_SIZE = 500000;
		var bigNumbersDelta = 0;
		if (startLineNumberVerticalOffset >= STEP_SIZE) {
			// Compute a delta that guarantees that lines are positioned at `lineHeight` increments
			bigNumbersDelta = Math.floor(startLineNumberVerticalOffset / STEP_SIZE) * STEP_SIZE;
			bigNumbersDelta = Math.floor(bigNumbersDelta / deviceLineHeight) * deviceLineHeight;

			currentLineRelativeOffset -= bigNumbersDelta;
		}

		var linesOffsets:number[] = [];

		// Figure out how far the lines go
		for (var lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {

			// Count current line height in the vertical offsets
			currentVerticalOffset += deviceLineHeight;
			linesOffsets.push(currentLineRelativeOffset);

			// Next line starts immediately after this one
			currentLineRelativeOffset += deviceLineHeight;
			while (currentWhitespaceAfterLineNumber === lineNumber) {
				// Push down next line with the height of the current whitespace
				currentLineRelativeOffset += currentWhitespaceHeight;

				// Count current whitespace in the vertical offsets
				currentVerticalOffset += currentWhitespaceHeight;
				whitespaceIndex++;

				if (whitespaceIndex >= whitespaceCount) {
					currentWhitespaceAfterLineNumber = endLineNumber + 1;
				} else {
					currentWhitespaceAfterLineNumber = this.whitespaces.getAfterLineNumberForWhitespaceIndex(whitespaceIndex);
					currentWhitespaceHeight = this.whitespaces.getHeightForWhitespaceIndex(whitespaceIndex);
				}
			}

			if (currentVerticalOffset > verticalOffset2) {
				// We have covered the entire viewport area, time to stop
				endLineNumber = lineNumber;
				break;
			}
		}

		return {
			viewportTop: verticalOffset1 - bigNumbersDelta,
			viewportHeight: verticalOffset2 - verticalOffset1,
			bigNumbersDelta: bigNumbersDelta,
			startLineNumber: startLineNumber,
			endLineNumber: endLineNumber,
			visibleRangesDeltaTop: -(verticalOffset1 - bigNumbersDelta),
			relativeVerticalOffset: linesOffsets,
			visibleRange: null, // This will be filled in by someone else :) (hint: viewLines)
			getInlineDecorationsForLineInViewport: null, // This will be filled in by linesLayout
			getDecorationsInViewport: null // This will be filled in by linesLayout
		};
	}

	/**
	 * Get all the lines and their relative vertical offsets that are positioned between `verticalOffset1` and `verticalOffset2`.
	 *
	 * @param verticalOffset1 The beginning of the viewport.
	 * @param verticalOffset2 The end of the viewport.
	 * @return A structure describing the lines positioned between `verticalOffset1` and `verticalOffset2`.
	 */
	public getLinesViewportData(verticalOffset1: number, verticalOffset2: number): IPartialViewLinesViewportData {
		verticalOffset1 = verticalOffset1 | 0;
		verticalOffset2 = verticalOffset2 | 0;
		const lineHeight = this._lineHeight;

		// Find first line number
		// We don't live in a perfect world, so the line number might start before or after verticalOffset1
		let startLineNumber = this.getLineNumberAtOrAfterVerticalOffset(verticalOffset1) | 0;

		let endLineNumber = this._lineCount | 0;
		let startLineNumberVerticalOffset = this.getVerticalOffsetForLineNumber(startLineNumber) | 0;

		// Also keep track of what whitespace we've got
		let whitespaceIndex = this._whitespaces.getFirstWhitespaceIndexAfterLineNumber(startLineNumber) | 0;
		let whitespaceCount = this._whitespaces.getCount() | 0;
		let currentWhitespaceHeight: number;
		let currentWhitespaceAfterLineNumber: number;

		if (whitespaceIndex === -1) {
			whitespaceIndex = whitespaceCount;
			currentWhitespaceAfterLineNumber = endLineNumber + 1;
			currentWhitespaceHeight = 0;
		} else {
			currentWhitespaceAfterLineNumber = this._whitespaces.getAfterLineNumberForWhitespaceIndex(whitespaceIndex) | 0;
			currentWhitespaceHeight = this._whitespaces.getHeightForWhitespaceIndex(whitespaceIndex) | 0;
		}

		let currentVerticalOffset = startLineNumberVerticalOffset;
		let currentLineRelativeOffset = currentVerticalOffset;

		// IE (all versions) cannot handle units above about 1,533,908 px, so every 500k pixels bring numbers down
		const STEP_SIZE = 500000;
		let bigNumbersDelta = 0;
		if (startLineNumberVerticalOffset >= STEP_SIZE) {
			// Compute a delta that guarantees that lines are positioned at `lineHeight` increments
			bigNumbersDelta = Math.floor(startLineNumberVerticalOffset / STEP_SIZE) * STEP_SIZE;
			bigNumbersDelta = Math.floor(bigNumbersDelta / lineHeight) * lineHeight;

			currentLineRelativeOffset -= bigNumbersDelta;
		}

		let linesOffsets: number[] = [];

		let verticalCenter = verticalOffset1 + (verticalOffset2 - verticalOffset1) / 2;
		let centeredLineNumber = -1;

		// Figure out how far the lines go
		for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {

			if (centeredLineNumber === -1) {
				let currentLineTop = currentVerticalOffset;
				let currentLineBottom = currentVerticalOffset + lineHeight;
				if ((currentLineTop <= verticalCenter && verticalCenter < currentLineBottom) || currentLineTop > verticalCenter) {
					centeredLineNumber = lineNumber;
				}
			}

			// Count current line height in the vertical offsets
			currentVerticalOffset += lineHeight;
			linesOffsets[lineNumber - startLineNumber] = currentLineRelativeOffset;

			// Next line starts immediately after this one
			currentLineRelativeOffset += lineHeight;
			while (currentWhitespaceAfterLineNumber === lineNumber) {
				// Push down next line with the height of the current whitespace
				currentLineRelativeOffset += currentWhitespaceHeight;

				// Count current whitespace in the vertical offsets
				currentVerticalOffset += currentWhitespaceHeight;
				whitespaceIndex++;

				if (whitespaceIndex >= whitespaceCount) {
					currentWhitespaceAfterLineNumber = endLineNumber + 1;
				} else {
					currentWhitespaceAfterLineNumber = this._whitespaces.getAfterLineNumberForWhitespaceIndex(whitespaceIndex) | 0;
					currentWhitespaceHeight = this._whitespaces.getHeightForWhitespaceIndex(whitespaceIndex) | 0;
				}
			}

			if (currentVerticalOffset >= verticalOffset2) {
				// We have covered the entire viewport area, time to stop
				endLineNumber = lineNumber;
				break;
			}
		}

		if (centeredLineNumber === -1) {
			centeredLineNumber = endLineNumber;
		}

		return {
			viewportTop: verticalOffset1 - bigNumbersDelta,
			viewportHeight: verticalOffset2 - verticalOffset1,
//.........这里部分代码省略.........