TypeScript Range.fromPositions方法代码示例

	setup(function () {

		model = TextModel.createFromString('FOO\nbar\BAR\nfoo', undefined, undefined, URI.parse('foo:bar/path'));
		registration = CompletionProviderRegistry.register({ pattern: 'bar/path', scheme: 'foo' }, {
			provideCompletionItems(_doc, pos) {
				return {
					incomplete: false,
					suggestions: [{
						label: 'aaa',
						kind: CompletionItemKind.Snippet,
						insertText: 'aaa',
						range: Range.fromPositions(pos)
					}, {
						label: 'zzz',
						kind: CompletionItemKind.Snippet,
						insertText: 'zzz',
						range: Range.fromPositions(pos)
					}, {
						label: 'fff',
						kind: CompletionItemKind.Property,
						insertText: 'fff',
						range: Range.fromPositions(pos)
					}]
				};
			}
		});
	});

	public run(accessor: ServicesAccessor, editor: ICodeEditor): void {
		if (!editor.hasModel()) {
			return;
		}

		let model = editor.getModel();
		let commands: ICommand[] = [];
		let selections = editor.getSelections();

		for (let selection of selections) {
			if (!selection.isEmpty()) {
				continue;
			}

			let lineNumber = selection.startLineNumber;
			let column = selection.startColumn;

			let lastColumn = model.getLineMaxColumn(lineNumber);

			if (lineNumber === 1 && (column === 1 || (column === 2 && lastColumn === 2))) {
				// at beginning of file, nothing to do
				continue;
			}

			// handle special case: when at end of line, transpose left two chars
			// otherwise, transpose left and right chars
			let endPosition = (column === lastColumn) ?
				selection.getPosition() :
				this.positionRightOf(selection.getPosition(), model);

			let middlePosition = this.positionLeftOf(endPosition, model);
			let beginPosition = this.positionLeftOf(middlePosition, model);

			let leftChar = model.getValueInRange(Range.fromPositions(beginPosition, middlePosition));
			let rightChar = model.getValueInRange(Range.fromPositions(middlePosition, endPosition));

			let replaceRange = Range.fromPositions(beginPosition, endPosition);
			commands.push(new ReplaceCommand(replaceRange, rightChar + leftChar));
		}

		if (commands.length > 0) {
			editor.pushUndoStop();
			editor.executeCommands(this.id, commands);
			editor.pushUndoStop();
		}
	}

	private _addTokenRange(bucket: Range[], model: ITextModel, pos: Position): void {
		const tokens = model.getLineTokens(pos.lineNumber);
		const index = tokens.findTokenIndexAtOffset(pos.column - 1);
		const type = tokens.getStandardTokenType(index);
		if (type === StandardTokenType.Other) {
			return;
		}

		// grow left
		let left: Position | undefined;
		{
			let leftIndex = index;
			let leftTokens = tokens;
			let leftLine = pos.lineNumber;
			while (!left) {
				let newLeftIndex = leftIndex - 1;
				if (newLeftIndex < 0) {
					if (leftLine > 1) {
						leftLine -= 1;
						leftTokens = model.getLineTokens(leftLine);
						leftIndex = leftTokens.getCount();
					} else {
						left = new Position(1, 1);
					}
				} else {
					if (leftTokens.getStandardTokenType(newLeftIndex) === type) {
						leftIndex = newLeftIndex;
					} else {
						if (newLeftIndex === leftTokens.getCount() - 1) {
							// we got here but there was nothing
							left = new Position(leftLine + 1, 1);

						} else {
							left = new Position(leftLine, leftTokens.getStartOffset(leftIndex) + 1);
						}
					}
				}
			}
		}

		// grow right
		let right: Position | undefined;
		{
			let rightIndex = index;
			let rightTokens = tokens;
			let rightLine = pos.lineNumber;
			while (!right) {
				let newRightIndex = rightIndex + 1;
				if (newRightIndex >= rightTokens.getCount()) {
					if (rightLine < model.getLineCount()) {
						rightLine += 1;
						rightTokens = model.getLineTokens(rightLine);
						rightIndex = -1;
					} else {
						right = new Position(model.getLineCount(), model.getLineMaxColumn(model.getLineCount()));
					}
				} else {
					if (rightTokens.getStandardTokenType(newRightIndex) === type) {
						rightIndex = newRightIndex;
					} else {
						if (newRightIndex === 0) {
							// we got here but there was nothing
							right = new Position(rightLine - 1, model.getLineMaxColumn(rightLine - 1));
						} else {
							right = new Position(rightLine, rightTokens.getEndOffset(rightIndex) + 1);
						}
					}
				}
			}
		}

		if (type === StandardTokenType.String) {
			// just assume that quotation marks are length=1
			bucket.push(Range.fromPositions(left.delta(0, 1), right.delta(0, -1)));
			bucket.push(Range.fromPositions(left, right));
		} else {
			bucket.push(Range.fromPositions(left, right));
		}
	}