Microsoft/vscode
1
0
Fork 0
mirror of https://github.com/microsoft/vscode.git synced 2026-03-03 23:39:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into benibenj/extensionBadgeNumber

Browse Source
This commit is contained in:
Benjamin Simmonds
2022-09-21 13:52:22 +02:00
committed by GitHub
parent aced4b9e09 bc2fe74dae
commit c36650ad41
11 changed files with 444 additions and 234 deletions
Download Patch File Download Diff File Expand all files Collapse all files

219
src/vs/editor/browser/controller/mouseHandler.ts
View File

@@ -5,12 +5,11 @@
import * as dom from 'vs/base/browser/dom';
import { StandardWheelEvent, IMouseWheelEvent } from 'vs/base/browser/mouseEvent';
import { TimeoutTimer } from 'vs/base/common/async';
import { Disposable, IDisposable } from 'vs/base/common/lifecycle';
import * as platform from 'vs/base/common/platform';
import { HitTestContext, MouseTarget, MouseTargetFactory, PointerHandlerLastRenderData } from 'vs/editor/browser/controller/mouseTarget';
import { IMouseTarget, IMouseTargetViewZoneData, MouseTargetType } from 'vs/editor/browser/editorBrowser';
import { ClientCoordinates, EditorMouseEvent, EditorMouseEventFactory, GlobalEditorPointerMoveMonitor, createEditorPagePosition, createCoordinatesRelativeToEditor } from 'vs/editor/browser/editorDom';
import { IMouseTarget, IMouseTargetOutsideEditor, IMouseTargetViewZoneData, MouseTargetType } from 'vs/editor/browser/editorBrowser';
import { ClientCoordinates, EditorMouseEvent, EditorMouseEventFactory, GlobalEditorPointerMoveMonitor, createEditorPagePosition, createCoordinatesRelativeToEditor, PageCoordinates } from 'vs/editor/browser/editorDom';
import { ViewController } from 'vs/editor/browser/view/viewController';
import { EditorZoom } from 'vs/editor/common/config/editorZoom';
import { Position } from 'vs/editor/common/core/position';
@@ -20,6 +19,7 @@ import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import * as viewEvents from 'vs/editor/common/viewEvents';
import { ViewEventHandler } from 'vs/editor/common/viewEventHandler';
import { EditorOption } from 'vs/editor/common/config/editorOptions';
import { NavigationCommandRevealType } from 'vs/editor/browser/coreCommands';
export interface IPointerHandlerHelper {
viewDomNode: HTMLElement;
@@ -34,6 +34,11 @@ export interface IPointerHandlerHelper {
*/
getLastRenderData(): PointerHandlerLastRenderData;
/**
* Render right now
*/
renderNow(): void;
shouldSuppressMouseDownOnViewZone(viewZoneId: string): boolean;
shouldSuppressMouseDownOnWidget(widgetId: string): boolean;
@@ -69,6 +74,7 @@ export class MouseHandler extends ViewEventHandler {
this._context,
this.viewController,
this.viewHelper,
this.mouseTargetFactory,
(e, testEventTarget) => this._createMouseTarget(e, testEventTarget),
(e) => this._getMouseColumn(e)
));
@@ -177,10 +183,6 @@ export class MouseHandler extends ViewEventHandler {
public override onFocusChanged(e: viewEvents.ViewFocusChangedEvent): boolean {
return false;
}
public override onScrollChanged(e: viewEvents.ViewScrollChangedEvent): boolean {
this._mouseDownOperation.onScrollChanged();
return false;
}
// --- end event handlers
public getTargetAtClientPoint(clientX: number, clientY: number): IMouseTarget | null {
@@ -313,14 +315,11 @@ export class MouseHandler extends ViewEventHandler {
class MouseDownOperation extends Disposable {
private readonly _context: ViewContext;
private readonly _viewController: ViewController;
private readonly _viewHelper: IPointerHandlerHelper;
private readonly _createMouseTarget: (e: EditorMouseEvent, testEventTarget: boolean) => IMouseTarget;
private readonly _getMouseColumn: (e: EditorMouseEvent) => number;
private readonly _mouseMoveMonitor: GlobalEditorPointerMoveMonitor;
private readonly _onScrollTimeout: TimeoutTimer;
private readonly _topBottomDragScrolling: TopBottomDragScrolling;
private readonly _mouseState: MouseDownState;
private _currentSelection: Selection;
@@ -328,21 +327,24 @@ class MouseDownOperation extends Disposable {
private _lastMouseEvent: EditorMouseEvent | null;
constructor(
context: ViewContext,
viewController: ViewController,
viewHelper: IPointerHandlerHelper,
private readonly _context: ViewContext,
private readonly _viewController: ViewController,
private readonly _viewHelper: IPointerHandlerHelper,
private readonly _mouseTargetFactory: MouseTargetFactory,
createMouseTarget: (e: EditorMouseEvent, testEventTarget: boolean) => IMouseTarget,
getMouseColumn: (e: EditorMouseEvent) => number
) {
super();
this._context = context;
this._viewController = viewController;
this._viewHelper = viewHelper;
this._createMouseTarget = createMouseTarget;
this._getMouseColumn = getMouseColumn;
this._mouseMoveMonitor = this._register(new GlobalEditorPointerMoveMonitor(this._viewHelper.viewDomNode));
this._onScrollTimeout = this._register(new TimeoutTimer());
this._topBottomDragScrolling = this._register(new TopBottomDragScrolling(
this._context,
this._viewHelper,
this._mouseTargetFactory,
(position, inSelectionMode, revealType) => this._dispatchMouse(position, inSelectionMode, revealType)
));
this._mouseState = new MouseDownState();
this._currentSelection = new Selection(1, 1, 1, 1);
@@ -374,7 +376,12 @@ class MouseDownOperation extends Disposable {
target: position
});
} else {
this._dispatchMouse(position, true);
if (position.type === MouseTargetType.OUTSIDE_EDITOR) {
this._topBottomDragScrolling.start(position, e);
} else {
this._topBottomDragScrolling.stop();
this._dispatchMouse(position, true, NavigationCommandRevealType.Minimal);
}
}
}
@@ -436,7 +443,7 @@ class MouseDownOperation extends Disposable {
}
this._mouseState.isDragAndDrop = false;
this._dispatchMouse(position, e.shiftKey);
this._dispatchMouse(position, e.shiftKey, NavigationCommandRevealType.Minimal);
if (!this._isActive) {
this._isActive = true;
@@ -452,7 +459,7 @@ class MouseDownOperation extends Disposable {
private _stop(): void {
this._isActive = false;
this._onScrollTimeout.cancel();
this._topBottomDragScrolling.stop();
}
public onHeightChanged(): void {
@@ -463,27 +470,6 @@ class MouseDownOperation extends Disposable {
this._mouseMoveMonitor.stopMonitoring();
}
public onScrollChanged(): void {
if (!this._isActive) {
return;
}
this._onScrollTimeout.setIfNotSet(() => {
if (!this._lastMouseEvent) {
return;
}
const position = this._findMousePosition(this._lastMouseEvent, false);
if (!position) {
// Ignoring because position is unknown
return;
}
if (this._mouseState.isDragAndDrop) {
// Ignoring because users are dragging the text
return;
}
this._dispatchMouse(position, true);
}, 10);
}
public onCursorStateChanged(e: viewEvents.ViewCursorStateChangedEvent): void {
this._currentSelection = e.selections[0];
}
@@ -496,41 +482,45 @@ class MouseDownOperation extends Disposable {
const mouseColumn = this._getMouseColumn(e);
if (e.posy < editorContent.y) {
const verticalOffset = Math.max(viewLayout.getCurrentScrollTop() - (editorContent.y - e.posy), 0);
const outsideDistance = editorContent.y - e.posy;
const verticalOffset = Math.max(viewLayout.getCurrentScrollTop() - outsideDistance, 0);
const viewZoneData = HitTestContext.getZoneAtCoord(this._context, verticalOffset);
if (viewZoneData) {
const newPosition = this._helpPositionJumpOverViewZone(viewZoneData);
if (newPosition) {
return MouseTarget.createOutsideEditor(mouseColumn, newPosition);
return MouseTarget.createOutsideEditor(mouseColumn, newPosition, 'above', outsideDistance);
}
}
const aboveLineNumber = viewLayout.getLineNumberAtVerticalOffset(verticalOffset);
return MouseTarget.createOutsideEditor(mouseColumn, new Position(aboveLineNumber, 1));
return MouseTarget.createOutsideEditor(mouseColumn, new Position(aboveLineNumber, 1), 'above', outsideDistance);
}
if (e.posy > editorContent.y + editorContent.height) {
const outsideDistance = e.posy - editorContent.y - editorContent.height;
const verticalOffset = viewLayout.getCurrentScrollTop() + e.relativePos.y;
const viewZoneData = HitTestContext.getZoneAtCoord(this._context, verticalOffset);
if (viewZoneData) {
const newPosition = this._helpPositionJumpOverViewZone(viewZoneData);
if (newPosition) {
return MouseTarget.createOutsideEditor(mouseColumn, newPosition);
return MouseTarget.createOutsideEditor(mouseColumn, newPosition, 'below', outsideDistance);
}
}
const belowLineNumber = viewLayout.getLineNumberAtVerticalOffset(verticalOffset);
return MouseTarget.createOutsideEditor(mouseColumn, new Position(belowLineNumber, model.getLineMaxColumn(belowLineNumber)));
return MouseTarget.createOutsideEditor(mouseColumn, new Position(belowLineNumber, model.getLineMaxColumn(belowLineNumber)), 'below', outsideDistance);
}
const possibleLineNumber = viewLayout.getLineNumberAtVerticalOffset(viewLayout.getCurrentScrollTop() + e.relativePos.y);
if (e.posx < editorContent.x) {
return MouseTarget.createOutsideEditor(mouseColumn, new Position(possibleLineNumber, 1));
const outsideDistance = editorContent.x - e.posx;
return MouseTarget.createOutsideEditor(mouseColumn, new Position(possibleLineNumber, 1), 'left', outsideDistance);
}
if (e.posx > editorContent.x + editorContent.width) {
return MouseTarget.createOutsideEditor(mouseColumn, new Position(possibleLineNumber, model.getLineMaxColumn(possibleLineNumber)));
const outsideDistance = e.posx - editorContent.x - editorContent.width;
return MouseTarget.createOutsideEditor(mouseColumn, new Position(possibleLineNumber, model.getLineMaxColumn(possibleLineNumber)), 'right', outsideDistance);
}
return null;
@@ -574,7 +564,7 @@ class MouseDownOperation extends Disposable {
return null;
}
private _dispatchMouse(position: IMouseTarget, inSelectionMode: boolean): void {
private _dispatchMouse(position: IMouseTarget, inSelectionMode: boolean, revealType: NavigationCommandRevealType): void {
if (!position.position) {
return;
}
@@ -582,6 +572,7 @@ class MouseDownOperation extends Disposable {
position: position.position,
mouseColumn: position.mouseColumn,
startedOnLineNumbers: this._mouseState.startedOnLineNumbers,
revealType,
inSelectionMode: inSelectionMode,
mouseDownCount: this._mouseState.count,
@@ -598,6 +589,134 @@ class MouseDownOperation extends Disposable {
}
}
class TopBottomDragScrolling extends Disposable {
private _operation: TopBottomDragScrollingOperation | null;
constructor(
private readonly _context: ViewContext,
private readonly _viewHelper: IPointerHandlerHelper,
private readonly _mouseTargetFactory: MouseTargetFactory,
private readonly _dispatchMouse: (position: IMouseTarget, inSelectionMode: boolean, revealType: NavigationCommandRevealType) => void,
) {
super();
this._operation = null;
}
public override dispose(): void {
super.dispose();
this.stop();
}
public start(position: IMouseTargetOutsideEditor, mouseEvent: EditorMouseEvent): void {
if (this._operation) {
this._operation.setPosition(position, mouseEvent);
} else {
this._operation = new TopBottomDragScrollingOperation(this._context, this._viewHelper, this._mouseTargetFactory, this._dispatchMouse, position, mouseEvent);
}
}
public stop(): void {
if (this._operation) {
this._operation.dispose();
this._operation = null;
}
}
}
class TopBottomDragScrollingOperation extends Disposable {
private _position: IMouseTargetOutsideEditor;
private _mouseEvent: EditorMouseEvent;
private _lastTime: number;
private _animationFrameDisposable: IDisposable;
constructor(
private readonly _context: ViewContext,
private readonly _viewHelper: IPointerHandlerHelper,
private readonly _mouseTargetFactory: MouseTargetFactory,
private readonly _dispatchMouse: (position: IMouseTarget, inSelectionMode: boolean, revealType: NavigationCommandRevealType) => void,
position: IMouseTargetOutsideEditor,
mouseEvent: EditorMouseEvent
) {
super();
this._position = position;
this._mouseEvent = mouseEvent;
this._lastTime = Date.now();
this._animationFrameDisposable = dom.scheduleAtNextAnimationFrame(() => this._execute());
}
public override dispose(): void {
this._animationFrameDisposable.dispose();
}
public setPosition(position: IMouseTargetOutsideEditor, mouseEvent: EditorMouseEvent): void {
this._position = position;
this._mouseEvent = mouseEvent;
}
/**
* update internal state and return elapsed ms since last time
*/
private _tick(): number {
const now = Date.now();
const elapsed = now - this._lastTime;
this._lastTime = now;
return elapsed;
}
/**
* get the number of lines per second to auto-scroll
*/
private _getScrollSpeed(): number {
const lineHeight = this._context.configuration.options.get(EditorOption.lineHeight);
const viewportInLines = this._context.configuration.options.get(EditorOption.layoutInfo).height / lineHeight;
const outsideDistanceInLines = this._position.outsideDistance / lineHeight;
if (outsideDistanceInLines <= 1.5) {
return Math.max(30, viewportInLines * (1 + outsideDistanceInLines));
}
if (outsideDistanceInLines <= 3) {
return Math.max(60, viewportInLines * (2 + outsideDistanceInLines));
}
return Math.max(200, viewportInLines * (7 + outsideDistanceInLines));
}
private _execute(): void {
const lineHeight = this._context.configuration.options.get(EditorOption.lineHeight);
const scrollSpeedInLines = this._getScrollSpeed();
const elapsed = this._tick();
const scrollInPixels = scrollSpeedInLines * (elapsed / 1000) * lineHeight;
const scrollValue = (this._position.outsidePosition === 'above' ? -scrollInPixels : scrollInPixels);
this._context.viewModel.viewLayout.deltaScrollNow(0, scrollValue);
this._viewHelper.renderNow();
const viewportData = this._context.viewLayout.getLinesViewportData();
const edgeLineNumber = (this._position.outsidePosition === 'above' ? viewportData.startLineNumber : viewportData.endLineNumber);
// First, try to find a position that matches the horizontal position of the mouse
let mouseTarget: IMouseTarget;
{
const editorPos = createEditorPagePosition(this._viewHelper.viewDomNode);
const horizontalScrollbarHeight = this._context.configuration.options.get(EditorOption.layoutInfo).horizontalScrollbarHeight;
const pos = new PageCoordinates(this._mouseEvent.pos.x, editorPos.y + editorPos.height - horizontalScrollbarHeight - 0.1);
const relativePos = createCoordinatesRelativeToEditor(this._viewHelper.viewDomNode, editorPos, pos);
mouseTarget = this._mouseTargetFactory.createMouseTarget(this._viewHelper.getLastRenderData(), editorPos, pos, relativePos, null);
}
if (!mouseTarget.position || mouseTarget.position.lineNumber !== edgeLineNumber) {
if (this._position.outsidePosition === 'above') {
mouseTarget = MouseTarget.createOutsideEditor(this._position.mouseColumn, new Position(edgeLineNumber, 1), 'above', this._position.outsideDistance);
} else {
mouseTarget = MouseTarget.createOutsideEditor(this._position.mouseColumn, new Position(edgeLineNumber, this._context.viewModel.getLineMaxColumn(edgeLineNumber)), 'below', this._position.outsideDistance);
}
}
this._dispatchMouse(mouseTarget, true, NavigationCommandRevealType.None);
this._animationFrameDisposable = dom.scheduleAtNextAnimationFrame(() => this._execute());
}
}
class MouseDownState {
private static readonly CLEAR_MOUSE_DOWN_COUNT_TIME = 400; // ms

4
src/vs/editor/browser/controller/mouseTarget.ts
View File

@@ -99,8 +99,8 @@ export class MouseTarget {
public static createOverlayWidget(element: Element | null, mouseColumn: number, detail: string): IMouseTargetOverlayWidget {
return { type: MouseTargetType.OVERLAY_WIDGET, element, mouseColumn, position: null, range: null, detail };
}
public static createOutsideEditor(mouseColumn: number, position: Position): IMouseTargetOutsideEditor {
return { type: MouseTargetType.OUTSIDE_EDITOR, element: null, mouseColumn, position, range: this._deduceRage(position) };
public static createOutsideEditor(mouseColumn: number, position: Position, outsidePosition: 'above' | 'below' | 'left' | 'right', outsideDistance: number): IMouseTargetOutsideEditor {
return { type: MouseTargetType.OUTSIDE_EDITOR, element: null, mouseColumn, position, range: this._deduceRage(position), outsidePosition, outsideDistance };
}
private static _typeToString(type: MouseTargetType): string {

4
src/vs/editor/browser/controller/pointerHandler.ts
View File

@@ -14,6 +14,7 @@ import { ViewController } from 'vs/editor/browser/view/viewController';
import { ViewContext } from 'vs/editor/common/viewModel/viewContext';
import { BrowserFeatures } from 'vs/base/browser/canIUse';
import { TextAreaSyntethicEvents } from 'vs/editor/browser/controller/textAreaInput';
import { NavigationCommandRevealType } from 'vs/editor/browser/coreCommands';
/**
* Currently only tested on iOS 13/ iPadOS.
@@ -66,6 +67,7 @@ export class PointerEventHandler extends MouseHandler {
position: target.position,
mouseColumn: target.position.column,
startedOnLineNumbers: false,
revealType: NavigationCommandRevealType.Minimal,
mouseDownCount: event.tapCount,
inSelectionMode: false,
altKey: false,
@@ -120,7 +122,7 @@ class TouchHandler extends MouseHandler {
event.initEvent(TextAreaSyntethicEvents.Tap, false, true);
this.viewHelper.dispatchTextAreaEvent(event);
this.viewController.moveTo(target.position);
this.viewController.moveTo(target.position, NavigationCommandRevealType.Minimal);
}
}

347
src/vs/editor/browser/coreCommands.ts
View File

File diff suppressed because it is too large Load Diff

2
src/vs/editor/browser/editorBrowser.ts
View File

@@ -391,6 +391,8 @@ export interface IMouseTargetOverviewRuler extends IBaseMouseTarget {
}
export interface IMouseTargetOutsideEditor extends IBaseMouseTarget {
readonly type: MouseTargetType.OUTSIDE_EDITOR;
readonly outsidePosition: 'above' | 'below' | 'left' | 'right';
readonly outsideDistance: number;
}
/**
* Target hit with the mouse in the editor.

3
src/vs/editor/browser/view.ts
View File

@@ -245,6 +245,9 @@ export class View extends ViewEventHandler {
const lastTextareaPosition = this._textAreaHandler.getLastRenderData();
return new PointerHandlerLastRenderData(lastViewCursorsRenderData, lastTextareaPosition);
},
renderNow: (): void => {
this.render(true, false);
},
shouldSuppressMouseDownOnViewZone: (viewZoneId: string) => {
return this._viewZones.shouldSuppressMouseDownOnViewZone(viewZoneId);
},

74
src/vs/editor/browser/view/viewController.ts
View File

@@ -4,7 +4,7 @@
*--------------------------------------------------------------------------------------------*/
import { IKeyboardEvent } from 'vs/base/browser/keyboardEvent';
import { CoreNavigationCommands } from 'vs/editor/browser/coreCommands';
import { CoreNavigationCommands, NavigationCommandRevealType } from 'vs/editor/browser/coreCommands';
import { IEditorMouseEvent, IPartialEditorMouseEvent } from 'vs/editor/browser/editorBrowser';
import { ViewUserInputEvents } from 'vs/editor/browser/view/viewUserInputEvents';
import { Position } from 'vs/editor/common/core/position';
@@ -21,6 +21,7 @@ export interface IMouseDispatchData {
* Desired mouse column (e.g. when position.column gets clamped to text length -- clicking after text on a line).
*/
mouseColumn: number;
revealType: NavigationCommandRevealType;
startedOnLineNumbers: boolean;
inSelectionMode: boolean;
@@ -138,15 +139,15 @@ export class ViewController {
// If the dragging started on the gutter, then have operations work on the entire line
if (this._hasMulticursorModifier(data)) {
if (data.inSelectionMode) {
this._lastCursorLineSelect(data.position);
this._lastCursorLineSelect(data.position, data.revealType);
} else {
this._createCursor(data.position, true);
}
} else {
if (data.inSelectionMode) {
this._lineSelectDrag(data.position);
this._lineSelectDrag(data.position, data.revealType);
} else {
this._lineSelect(data.position);
this._lineSelect(data.position, data.revealType);
}
}
} else if (data.mouseDownCount >= 4) {
@@ -154,26 +155,26 @@ export class ViewController {
} else if (data.mouseDownCount === 3) {
if (this._hasMulticursorModifier(data)) {
if (data.inSelectionMode) {
this._lastCursorLineSelectDrag(data.position);
this._lastCursorLineSelectDrag(data.position, data.revealType);
} else {
this._lastCursorLineSelect(data.position);
this._lastCursorLineSelect(data.position, data.revealType);
}
} else {
if (data.inSelectionMode) {
this._lineSelectDrag(data.position);
this._lineSelectDrag(data.position, data.revealType);
} else {
this._lineSelect(data.position);
this._lineSelect(data.position, data.revealType);
}
}
} else if (data.mouseDownCount === 2) {
if (!data.onInjectedText) {
if (this._hasMulticursorModifier(data)) {
this._lastCursorWordSelect(data.position);
this._lastCursorWordSelect(data.position, data.revealType);
} else {
if (data.inSelectionMode) {
this._wordSelectDrag(data.position);
this._wordSelectDrag(data.position, data.revealType);
} else {
this._wordSelect(data.position);
this._wordSelect(data.position, data.revealType);
}
}
}
@@ -185,7 +186,7 @@ export class ViewController {
} else {
// Do multi-cursor operations only when purely alt is pressed
if (data.inSelectionMode) {
this._lastCursorMoveToSelect(data.position);
this._lastCursorMoveToSelect(data.position, data.revealType);
} else {
this._createCursor(data.position, false);
}
@@ -199,31 +200,32 @@ export class ViewController {
if (columnSelection) {
this._columnSelect(data.position, data.mouseColumn, true);
} else {
this._moveToSelect(data.position);
this._moveToSelect(data.position, data.revealType);
}
}
} else {
this.moveTo(data.position);
this.moveTo(data.position, data.revealType);
}
}
}
}
private _usualArgs(viewPosition: Position) {
private _usualArgs(viewPosition: Position, revealType: NavigationCommandRevealType): CoreNavigationCommands.MoveCommandOptions {
viewPosition = this._validateViewColumn(viewPosition);
return {
source: 'mouse',
position: this._convertViewToModelPosition(viewPosition),
viewPosition: viewPosition
viewPosition,
revealType
};
}
public moveTo(viewPosition: Position): void {
CoreNavigationCommands.MoveTo.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
public moveTo(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.MoveTo.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _moveToSelect(viewPosition: Position): void {
CoreNavigationCommands.MoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
private _moveToSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.MoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _columnSelect(viewPosition: Position, mouseColumn: number, doColumnSelect: boolean): void {
@@ -247,36 +249,36 @@ export class ViewController {
});
}
private _lastCursorMoveToSelect(viewPosition: Position): void {
CoreNavigationCommands.LastCursorMoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
private _lastCursorMoveToSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.LastCursorMoveToSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _wordSelect(viewPosition: Position): void {
CoreNavigationCommands.WordSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
private _wordSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.WordSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _wordSelectDrag(viewPosition: Position): void {
CoreNavigationCommands.WordSelectDrag.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
private _wordSelectDrag(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.WordSelectDrag.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _lastCursorWordSelect(viewPosition: Position): void {
CoreNavigationCommands.LastCursorWordSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
private _lastCursorWordSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.LastCursorWordSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _lineSelect(viewPosition: Position): void {
CoreNavigationCommands.LineSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
private _lineSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.LineSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _lineSelectDrag(viewPosition: Position): void {
CoreNavigationCommands.LineSelectDrag.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
private _lineSelectDrag(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.LineSelectDrag.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _lastCursorLineSelect(viewPosition: Position): void {
CoreNavigationCommands.LastCursorLineSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
private _lastCursorLineSelect(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.LastCursorLineSelect.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _lastCursorLineSelectDrag(viewPosition: Position): void {
CoreNavigationCommands.LastCursorLineSelectDrag.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition));
private _lastCursorLineSelectDrag(viewPosition: Position, revealType: NavigationCommandRevealType): void {
CoreNavigationCommands.LastCursorLineSelectDrag.runCoreEditorCommand(this.viewModel, this._usualArgs(viewPosition, revealType));
}
private _selectAll(): void {

13
src/vs/editor/browser/viewParts/lines/viewLines.ts
View File

@@ -102,7 +102,6 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
private _typicalHalfwidthCharacterWidth: number;
private _isViewportWrapping: boolean;
private _revealHorizontalRightPadding: number;
private _horizontalScrollbarHeight: number;
private _cursorSurroundingLines: number;
private _cursorSurroundingLinesStyle: 'default' | 'all';
private _canUseLayerHinting: boolean;
@@ -131,13 +130,11 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
const options = this._context.configuration.options;
const fontInfo = options.get(EditorOption.fontInfo);
const wrappingInfo = options.get(EditorOption.wrappingInfo);
const layoutInfo = options.get(EditorOption.layoutInfo);
this._lineHeight = options.get(EditorOption.lineHeight);
this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
this._isViewportWrapping = wrappingInfo.isViewportWrapping;
this._revealHorizontalRightPadding = options.get(EditorOption.revealHorizontalRightPadding);
this._horizontalScrollbarHeight = layoutInfo.horizontalScrollbarHeight;
this._cursorSurroundingLines = options.get(EditorOption.cursorSurroundingLines);
this._cursorSurroundingLinesStyle = options.get(EditorOption.cursorSurroundingLinesStyle);
this._canUseLayerHinting = !options.get(EditorOption.disableLayerHinting);
@@ -194,13 +191,11 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
const options = this._context.configuration.options;
const fontInfo = options.get(EditorOption.fontInfo);
const wrappingInfo = options.get(EditorOption.wrappingInfo);
const layoutInfo = options.get(EditorOption.layoutInfo);
this._lineHeight = options.get(EditorOption.lineHeight);
this._typicalHalfwidthCharacterWidth = fontInfo.typicalHalfwidthCharacterWidth;
this._isViewportWrapping = wrappingInfo.isViewportWrapping;
this._revealHorizontalRightPadding = options.get(EditorOption.revealHorizontalRightPadding);
this._horizontalScrollbarHeight = layoutInfo.horizontalScrollbarHeight;
this._cursorSurroundingLines = options.get(EditorOption.cursorSurroundingLines);
this._cursorSurroundingLinesStyle = options.get(EditorOption.cursorSurroundingLinesStyle);
this._canUseLayerHinting = !options.get(EditorOption.disableLayerHinting);
@@ -697,9 +692,11 @@ export class ViewLines extends ViewPart implements IVisibleLinesHost<ViewLine>,
paddingTop = this._lineHeight;
}
}
if (verticalType === viewEvents.VerticalRevealType.Simple || verticalType === viewEvents.VerticalRevealType.Bottom) {
// Reveal one line more when the last line would be covered by the scrollbar - arrow down case or revealing a line explicitly at bottom
paddingBottom += (minimalReveal ? this._horizontalScrollbarHeight : this._lineHeight);
if (!minimalReveal) {
if (verticalType === viewEvents.VerticalRevealType.Simple || verticalType === viewEvents.VerticalRevealType.Bottom) {
// Reveal one line more when the last line would be covered by the scrollbar - arrow down case or revealing a line explicitly at bottom
paddingBottom += this._lineHeight;
}
}
boxStartY -= paddingTop;

6
src/vs/editor/common/cursor/cursorMoveCommands.ts
View File

@@ -173,7 +173,7 @@ export class CursorMoveCommands {
));
}
public static line(viewModel: IViewModel, cursor: CursorState, inSelectionMode: boolean, _position: IPosition, _viewPosition: IPosition): PartialCursorState {
public static line(viewModel: IViewModel, cursor: CursorState, inSelectionMode: boolean, _position: IPosition, _viewPosition: IPosition | undefined): PartialCursorState {
const position = viewModel.model.validatePosition(_position);
const viewPosition = (
_viewPosition
@@ -251,7 +251,7 @@ export class CursorMoveCommands {
));
}
public static moveTo(viewModel: IViewModel, cursor: CursorState, inSelectionMode: boolean, _position: IPosition, _viewPosition: IPosition): PartialCursorState {
public static moveTo(viewModel: IViewModel, cursor: CursorState, inSelectionMode: boolean, _position: IPosition, _viewPosition: IPosition | undefined): PartialCursorState {
const position = viewModel.model.validatePosition(_position);
const viewPosition = (
_viewPosition
@@ -680,7 +680,7 @@ export namespace CursorMove {
value?: number;
}
export function parse(args: RawArguments): ParsedArguments | null {
export function parse(args: Partial<RawArguments>): ParsedArguments | null {
if (!args.to) {
// illegal arguments
return null;

2
src/vs/monaco.d.ts vendored
View File

@@ -5046,6 +5046,8 @@ declare namespace monaco.editor {
export interface IMouseTargetOutsideEditor extends IBaseMouseTarget {
readonly type: MouseTargetType.OUTSIDE_EDITOR;
readonly outsidePosition: 'above' | 'below' | 'left' | 'right';
readonly outsideDistance: number;
}
/**

4
src/vs/workbench/contrib/userDataSync/browser/userDataSync.ts
View File

@@ -835,7 +835,7 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
icon: Codicon.stopCircle,
menu: {
id: MenuId.ViewContainerTitle,
when: ContextKeyExpr.and(CONTEXT_SYNC_STATE.notEqualsTo(SyncStatus.Uninitialized), CONTEXT_SYNC_ENABLEMENT.toNegated(), CONTEXT_ACCOUNT_STATE.notEqualsTo(AccountStatus.Uninitialized), CONTEXT_TURNING_ON_STATE, ContextKeyExpr.equals('viewContainer', SYNC_VIEW_CONTAINER_ID)),
when: ContextKeyExpr.and(CONTEXT_TURNING_ON_STATE, ContextKeyExpr.equals('viewContainer', SYNC_VIEW_CONTAINER_ID)),
group: 'navigation',
order: 1
}
@@ -1057,7 +1057,7 @@ export class UserDataSyncWorkbenchContribution extends Disposable implements IWo
when
}, {
id: MenuId.ViewContainerTitle,
when: ContextKeyExpr.and(when, ContextKeyExpr.equals('viewContainer', SYNC_VIEW_CONTAINER_ID)),
when: ContextKeyExpr.and(CONTEXT_SYNC_ENABLEMENT, ContextKeyExpr.equals('viewContainer', SYNC_VIEW_CONTAINER_ID)),
group: 'navigation',
order: 2
}]