Added support for Virtual Space

Author: jamiefutch

.gitignore

@@ -45,3 +45,4 @@ dist
 .github/prompts/*.local.prompt.md
 .agents/skills/.local/
 .github/skills/.local/
+.antigravity/

src/vs/editor/browser/coreCommands.ts

@@ -374,6 +374,7 @@ export namespace CoreNavigationCommands {
 	export interface MoveCommandOptions extends BaseCommandOptions {
 		position: IPosition;
 		viewPosition?: IPosition;
+		leftoverVisibleColumns?: number;
 		revealType: NavigationCommandRevealType;
 	}
 
@@ -395,7 +396,7 @@ export namespace CoreNavigationCommands {
 				args.source,
 				CursorChangeReason.Explicit,
 				[
-					CursorMoveCommands.moveTo(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position, args.viewPosition)
+					CursorMoveCommands.moveTo(viewModel, viewModel.getPrimaryCursorState(), this._inSelectionMode, args.position, args.viewPosition, args.leftoverVisibleColumns)
 				]
 			);
 			if (cursorStateChanged && args.revealType !== NavigationCommandRevealType.None) {

src/vs/editor/browser/view/viewController.ts

@@ -17,6 +17,7 @@ import * as platform from '../../../base/common/platform.js';
 import { StandardTokenType } from '../../common/encodedTokenAttributes.js';
 import { ITextModel } from '../../common/model.js';
 import { containsRTL } from '../../../base/common/strings.js';
+import { CursorColumns } from '../../common/core/cursorColumns.js';
 
 export interface IMouseDispatchData {
 	position: Position;
@@ -286,7 +287,7 @@ export class ViewController {
 					} else {
 						// Do multi-cursor operations only when purely alt is pressed
 						if (data.inSelectionMode) {
-							this._lastCursorMoveToSelect(data.position, data.revealType);
+							this._lastCursorMoveToSelect(data.position, data.mouseColumn, data.revealType);
 						} else {
 							this._createCursor(data.position, false);
 						}
@@ -300,32 +301,63 @@ export class ViewController {
 						if (columnSelection) {
 							this._columnSelect(data.position, data.mouseColumn, true);
 						} else {
-							this._moveToSelect(data.position, data.revealType);
+							this._moveToSelect(data.position, data.mouseColumn, data.revealType);
 						}
 					}
 				} else {
-					this.moveTo(data.position, data.revealType);
+					this.moveTo(data.position, data.mouseColumn, data.revealType);
 				}
 			}
 		}
 	}
 
-	private _usualArgs(viewPosition: Position, revealType: NavigationCommandRevealType): CoreNavigationCommands.MoveCommandOptions {
+	private _usualArgs(viewPosition: Position, revealType: NavigationCommandRevealType): CoreNavigationCommands.MoveCommandOptions;
+	private _usualArgs(viewPosition: Position, mouseColumn: number, revealType: NavigationCommandRevealType): CoreNavigationCommands.MoveCommandOptions;
+	private _usualArgs(viewPosition: Position, arg2: number | NavigationCommandRevealType, arg3?: NavigationCommandRevealType): CoreNavigationCommands.MoveCommandOptions {
 		viewPosition = this._validateViewColumn(viewPosition);
+		let mouseColumn: number;
+		let revealType: NavigationCommandRevealType;
+		if (arg3 !== undefined) {
+			mouseColumn = arg2 as number;
+			revealType = arg3;
+		} else {
+			mouseColumn = CursorColumns.visibleColumnFromColumn(this.viewModel.getLineContent(viewPosition.lineNumber), viewPosition.column, this.viewModel.model.getOptions().tabSize) + 1;
+			revealType = arg2 as NavigationCommandRevealType;
+		}
+
+		let leftoverVisibleColumns = 0;
+		if (this.configuration.options.get(EditorOption.virtualSpace)) {
+			const maxColumn = this.viewModel.getLineMaxColumn(viewPosition.lineNumber);
+			const maxVisibleColumn = CursorColumns.visibleColumnFromColumn(this.viewModel.getLineContent(viewPosition.lineNumber), maxColumn, this.viewModel.model.getOptions().tabSize);
+			leftoverVisibleColumns = Math.max(0, (mouseColumn - 1) - maxVisibleColumn);
+		}
 		return {
 			source: 'mouse',
 			position: this._convertViewToModelPosition(viewPosition),
 			viewPosition,
+			leftoverVisibleColumns,
 			revealType
 		};
 	}
 
-	public moveTo(viewPosition: Position, revealType: NavigationCommandRevealType): void {
-		CoreNavigationCommands.MoveTo.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
+	public moveTo(viewPosition: Position, revealType: NavigationCommandRevealType): void;
+	public moveTo(viewPosition: Position, mouseColumn: number, revealType: NavigationCommandRevealType): void;
+	public moveTo(viewPosition: Position, arg2: number | NavigationCommandRevealType, arg3?: NavigationCommandRevealType): void {
+		if (arg3 !== undefined) {
+			CoreNavigationCommands.MoveTo.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, arg2 as number, arg3));
+		} else {
+			CoreNavigationCommands.MoveTo.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, arg2 as NavigationCommandRevealType));
+		}
 	}
 
-	private _moveToSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void {
-		CoreNavigationCommands.MoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
+	private _moveToSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void;
+	private _moveToSelect(viewPosition: Position, mouseColumn: number, revealType: NavigationCommandRevealType): void;
+	private _moveToSelect(viewPosition: Position, arg2: number | NavigationCommandRevealType, arg3?: NavigationCommandRevealType): void {
+		if (arg3 !== undefined) {
+			CoreNavigationCommands.MoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, arg2 as number, arg3));
+		} else {
+			CoreNavigationCommands.MoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, arg2 as NavigationCommandRevealType));
+		}
 	}
 
 	private _columnSelect(viewPosition: Position, mouseColumn: number, doColumnSelect: boolean): void {
@@ -349,8 +381,14 @@ export class ViewController {
 		});
 	}
 
-	private _lastCursorMoveToSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void {
-		CoreNavigationCommands.LastCursorMoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
+	private _lastCursorMoveToSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void;
+	private _lastCursorMoveToSelect(viewPosition: Position, mouseColumn: number, revealType: NavigationCommandRevealType): void;
+	private _lastCursorMoveToSelect(viewPosition: Position, arg2: number | NavigationCommandRevealType, arg3?: NavigationCommandRevealType): void {
+		if (arg3 !== undefined) {
+			CoreNavigationCommands.LastCursorMoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, arg2 as number, arg3));
+		} else {
+			CoreNavigationCommands.LastCursorMoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, arg2 as NavigationCommandRevealType));
+		}
 	}
 
 	private _wordSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void {

src/vs/editor/browser/viewParts/viewCursors/viewCursor.ts

@@ -53,6 +53,7 @@ export class ViewCursor {
 	private _isVisible: boolean;
 
 	private _position: Position;
+	private _leftoverVisibleColumns: number;
 	private _pluralityClass: string;
 
 	private _lastRenderedContent: string;
@@ -80,6 +81,7 @@ export class ViewCursor {
 		this._domNode.setDisplay('none');
 
 		this._position = new Position(1, 1);
+		this._leftoverVisibleColumns = 0;
 		this._pluralityClass = '';
 		this.setPlurality(plurality);
 
@@ -139,13 +141,14 @@ export class ViewCursor {
 		return true;
 	}
 
-	public onCursorPositionChanged(position: Position, pauseAnimation: boolean): boolean {
+	public onCursorPositionChanged(position: Position, leftoverVisibleColumns: number, pauseAnimation: boolean): boolean {
 		if (pauseAnimation) {
 			this._domNode.domNode.style.transitionProperty = 'none';
 		} else {
 			this._domNode.domNode.style.transitionProperty = '';
 		}
 		this._position = position;
+		this._leftoverVisibleColumns = leftoverVisibleColumns;
 		return true;
 	}
 
@@ -192,6 +195,9 @@ export class ViewCursor {
 			}
 
 			let left = visibleRange.left;
+			if (this._leftoverVisibleColumns > 0 && this._leftoverVisibleColumns < 1000000 && this._context.configuration.options.get(EditorOption.virtualSpace)) {
+				left += this._leftoverVisibleColumns * this._typicalHalfwidthCharacterWidth;
+			}
 			let paddingLeft = 0;
 			if (width >= 2 && left >= 1) {
 				// shift the cursor a bit between the characters
@@ -238,7 +244,12 @@ export class ViewCursor {
 			height = 2;
 		}
 
-		return new ViewCursorRenderData(top, range.left, 0, width, height, textContent, textContentClassName);
+		let left = range.left;
+		if (this._leftoverVisibleColumns > 0 && this._leftoverVisibleColumns < 1000000 && this._context.configuration.options.get(EditorOption.virtualSpace)) {
+			left += this._leftoverVisibleColumns * this._typicalHalfwidthCharacterWidth;
+		}
+
+		return new ViewCursorRenderData(top, left, 0, width, height, textContent, textContentClassName);
 	}
 
 	private _getTokenClassName(position: Position): string {

src/vs/editor/browser/viewParts/viewCursors/viewCursors.ts

@@ -127,13 +127,13 @@ export class ViewCursors extends ViewPart {
 		}
 		return true;
 	}
-	private _onCursorPositionChanged(position: Position, secondaryPositions: Position[], reason: CursorChangeReason): void {
+	private _onCursorPositionChanged(position: Position, leftoverVisibleColumns: number, secondaryPositions: Position[], secondaryLeftoverVisibleColumns: number[], reason: CursorChangeReason): void {
 		const pauseAnimation = (
 			this._secondaryCursors.length !== secondaryPositions.length
 			|| (this._cursorSmoothCaretAnimation === 'explicit' && reason !== CursorChangeReason.Explicit)
 		);
 		this._primaryCursor.setPlurality(secondaryPositions.length ? CursorPlurality.MultiPrimary : CursorPlurality.Single);
-		this._primaryCursor.onCursorPositionChanged(position, pauseAnimation);
+		this._primaryCursor.onCursorPositionChanged(position, leftoverVisibleColumns, pauseAnimation);
 		this._updateBlinking();
 
 		if (this._secondaryCursors.length < secondaryPositions.length) {
@@ -154,7 +154,7 @@ export class ViewCursors extends ViewPart {
 		}
 
 		for (let i = 0; i < secondaryPositions.length; i++) {
-			this._secondaryCursors[i].onCursorPositionChanged(secondaryPositions[i], pauseAnimation);
+			this._secondaryCursors[i].onCursorPositionChanged(secondaryPositions[i], secondaryLeftoverVisibleColumns[i], pauseAnimation);
 		}
 
 	}
@@ -163,7 +163,7 @@ export class ViewCursors extends ViewPart {
 		for (let i = 0, len = e.selections.length; i < len; i++) {
 			positions[i] = e.selections[i].getPosition();
 		}
-		this._onCursorPositionChanged(positions[0], positions.slice(1), e.reason);
+		this._onCursorPositionChanged(positions[0], e.leftoverVisibleColumns[0], positions.slice(1), e.leftoverVisibleColumns.slice(1), e.reason);
 
 		const selectionIsEmpty = e.selections[0].isEmpty();
 		if (this._selectionIsEmpty !== selectionIsEmpty) {

src/vs/editor/common/config/editorOptions.ts

@@ -800,6 +800,10 @@ export interface IEditorOptions {
 	 * Controls whether suggestions allow matches in the middle of the word instead of only at the beginning
 	 */
 	matchOnWordStartOnly?: boolean;
+	/**
+	 * Controls whether the cursor should be allowed to move into virtual space.
+	 */
+	virtualSpace?: boolean;
 	/**
 	 * Control the behavior and rendering of the inline hints.
 	 */
@@ -5931,6 +5935,10 @@ export const enum EditorOption {
 	inertialScroll,
 	inlayHints,
 	wrapOnEscapedLineFeeds,
+	/**
+	 * Controls whether the cursor should be allowed to move into virtual space.
+	 */
+	virtualSpace,
 	// Leave these at the end (because they have dependencies!)
 	effectiveCursorStyle,
 	editorClassName,
@@ -6742,6 +6750,10 @@ export const EditorOptions = {
 	useShadowDOM: register(new EditorBooleanOption(
 		EditorOption.useShadowDOM, 'useShadowDOM', true
 	)),
+	virtualSpace: register(new EditorBooleanOption(
+		EditorOption.virtualSpace, 'virtualSpace', false,
+		{ description: nls.localize('virtualSpace', "Controls whether the cursor should be allowed to move into virtual space.") }
+	)),
 	useTabStops: register(new EditorBooleanOption(
 		EditorOption.useTabStops, 'useTabStops', true,
 		{ description: nls.localize('useTabStops', "Spaces and tabs are inserted and deleted in alignment with tab stops.") }

src/vs/editor/common/cursor/cursor.ts

@@ -406,11 +406,13 @@ export class CursorsController extends Disposable {
 			return false;
 		}
 
+		const cursorStates = this._cursors.getAll();
 		const selections = this._cursors.getSelections();
 		const viewSelections = this._cursors.getViewSelections();
+		const leftoverVisibleColumns = cursorStates.map(s => s.viewState.leftoverVisibleColumns);
 
 		// Let the view get the event first.
-		eventsCollector.emitViewEvent(new ViewCursorStateChangedEvent(viewSelections, selections, reason));
+		eventsCollector.emitViewEvent(new ViewCursorStateChangedEvent(viewSelections, selections, leftoverVisibleColumns, reason));
 
 		// Only after the view has been notified, let the rest of the world know...
 		if (!oldState
@@ -566,14 +568,19 @@ export class CursorsController extends Disposable {
 					const charLength = strings.nextCharLength(text, offset);
 					const chr = text.substr(offset, charLength);
 
+					const cursorStates = this._cursors.getAll();
+					const leftoverVisibleColumns = cursorStates.map(s => s.viewState.leftoverVisibleColumns);
+
 					// Here we must interpret each typed character individually
-					this._executeEditOperation(TypeOperations.typeWithInterceptors(!!this._compositionState, this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), this.getAutoClosedCharacters(), chr), reason);
+					this._executeEditOperation(TypeOperations.typeWithInterceptors(!!this._compositionState, this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), leftoverVisibleColumns, this.getAutoClosedCharacters(), chr), reason);
 
 					offset += charLength;
 				}
 
 			} else {
-				this._executeEditOperation(TypeOperations.typeWithoutInterceptors(this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), text), reason);
+				const cursorStates = this._cursors.getAll();
+				const leftoverVisibleColumns = cursorStates.map(s => s.viewState.leftoverVisibleColumns);
+				this._executeEditOperation(TypeOperations.typeWithoutInterceptors(this._prevEditOperationType, this.context.cursorConfig, this._model, this.getSelections(), leftoverVisibleColumns, text), reason);
 			}
 		}, eventsCollector, source);
 	}
@@ -601,8 +608,10 @@ export class CursorsController extends Disposable {
 	public paste(eventsCollector: ViewModelEventsCollector, text: string, pasteOnNewLine: boolean, multicursorText?: string[] | null | undefined, source?: string | null | undefined): void {
 		const reason = EditSources.cursor({ kind: 'paste', detailedSource: source });
 
+		const cursorStates = this._cursors.getAll();
+		const leftoverVisibleColumns = cursorStates.map(s => s.viewState.leftoverVisibleColumns);
 		this._executeEdit(() => {
-			this._executeEditOperation(TypeOperations.paste(this.context.cursorConfig, this._model, this.getSelections(), text, pasteOnNewLine, multicursorText || []), reason);
+			this._executeEditOperation(TypeOperations.paste(this.context.cursorConfig, this._model, this.getSelections(), leftoverVisibleColumns, text, pasteOnNewLine, multicursorText || []), reason);
 		}, eventsCollector, source, CursorChangeReason.Paste);
 	}
 

src/vs/editor/common/cursor/cursorColumnSelection.ts

@@ -17,8 +17,6 @@ export class ColumnSelection {
 
 		const result: SingleCursorState[] = [];
 
-		// console.log(`fromVisibleColumn: ${fromVisibleColumn}, toVisibleColumn: ${toVisibleColumn}`);
-
 		for (let i = 0; i < lineCount; i++) {
 			const lineNumber = fromLineNumber + (reversed ? -i : i);
 
@@ -27,29 +25,30 @@ export class ColumnSelection {
 			const visibleStartColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, startColumn));
 			const visibleEndColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, endColumn));
 
-			// console.log(`lineNumber: ${lineNumber}: visibleStartColumn: ${visibleStartColumn}, visibleEndColumn: ${visibleEndColumn}`);
+			const leftoverStartColumn = Math.max(0, fromVisibleColumn - visibleStartColumn);
+			const leftoverEndColumn = Math.max(0, toVisibleColumn - visibleEndColumn);
 
 			if (isLTR) {
-				if (visibleStartColumn > toVisibleColumn) {
+				if (visibleStartColumn + leftoverStartColumn > toVisibleColumn) {
 					continue;
 				}
-				if (visibleEndColumn < fromVisibleColumn) {
+				if (visibleEndColumn + leftoverEndColumn < fromVisibleColumn) {
 					continue;
 				}
 			}
 
 			if (isRTL) {
-				if (visibleEndColumn > fromVisibleColumn) {
+				if (visibleEndColumn + leftoverEndColumn > fromVisibleColumn) {
 					continue;
 				}
-				if (visibleStartColumn < toVisibleColumn) {
+				if (visibleStartColumn + leftoverStartColumn < toVisibleColumn) {
 					continue;
 				}
 			}
 
 			result.push(new SingleCursorState(
-				new Range(lineNumber, startColumn, lineNumber, startColumn), SelectionStartKind.Simple, 0,
-				new Position(lineNumber, endColumn), 0
+				new Range(lineNumber, startColumn, lineNumber, startColumn), SelectionStartKind.Simple, leftoverStartColumn,
+				new Position(lineNumber, endColumn), leftoverEndColumn
 			));
 		}
 
@@ -58,10 +57,14 @@ export class ColumnSelection {
 			for (let i = 0; i < lineCount; i++) {
 				const lineNumber = fromLineNumber + (reversed ? -i : i);
 				const maxColumn = model.getLineMaxColumn(lineNumber);
+				const maxVisibleColumn = config.visibleColumnFromColumn(model, new Position(lineNumber, maxColumn));
+
+				const leftoverStartColumn = Math.max(0, fromVisibleColumn - maxVisibleColumn);
+				const leftoverEndColumn = Math.max(0, toVisibleColumn - maxVisibleColumn);
 
 				result.push(new SingleCursorState(
-					new Range(lineNumber, maxColumn, lineNumber, maxColumn), SelectionStartKind.Simple, 0,
-					new Position(lineNumber, maxColumn), 0
+					new Range(lineNumber, maxColumn, lineNumber, maxColumn), SelectionStartKind.Simple, leftoverStartColumn,
+					new Position(lineNumber, maxColumn), leftoverEndColumn
 				));
 			}
 		}

src/vs/editor/common/cursor/cursorMoveCommands.ts

@@ -252,7 +252,7 @@ export class CursorMoveCommands {
 		));
 	}
 
-	public static moveTo(viewModel: IViewModel, cursor: CursorState, inSelectionMode: boolean, _position: IPosition, _viewPosition: IPosition | undefined): PartialCursorState {
+	public static moveTo(viewModel: IViewModel, cursor: CursorState, inSelectionMode: boolean, _position: IPosition, _viewPosition: IPosition | undefined, leftoverVisibleColumns: number = 0): PartialCursorState {
 		if (inSelectionMode) {
 			if (cursor.modelState.selectionStartKind === SelectionStartKind.Word) {
 				return this.word(viewModel, cursor, inSelectionMode, _position);
@@ -267,7 +267,7 @@ export class CursorMoveCommands {
 				? viewModel.coordinatesConverter.validateViewPosition(new Position(_viewPosition.lineNumber, _viewPosition.column), position)
 				: viewModel.coordinatesConverter.convertModelPositionToViewPosition(position)
 		);
-		return CursorState.fromViewState(cursor.viewState.move(inSelectionMode, viewPosition.lineNumber, viewPosition.column, 0));
+		return CursorState.fromViewState(cursor.viewState.move(inSelectionMode, viewPosition.lineNumber, viewPosition.column, leftoverVisibleColumns));
 	}
 
 	public static simpleMove(viewModel: IViewModel, cursors: CursorState[], direction: CursorMove.SimpleMoveDirection, inSelectionMode: boolean, value: number, unit: CursorMove.Unit): PartialCursorState[] | null {