@codingame/monaco-vscode-api 2.0.3 → 2.1.0-update-vscode-1.86.1

package/vscode/src/vs/editor/browser/services/hoverService.js

@@ -0,0 +1,195 @@
+import { __decorate, __param } from '../../../../../../external/tslib/tslib.es6.js';
+import { registerSingleton } from '../../../platform/instantiation/common/extensions.js';
+import { registerThemingParticipant } from '../../../platform/theme/common/themeService.js';
+import { editorHoverBorder } from '../../../platform/theme/common/colorRegistry.js';
+import { IHoverService } from '../../../platform/hover/browser/hover.js';
+import { IContextViewService, IContextMenuService } from '../../../platform/contextview/browser/contextView.js';
+import { IInstantiationService } from '../../../platform/instantiation/common/instantiation.js';
+import { HoverWidget } from '../widget/hoverWidget/hoverWidget.js';
+import { toDisposable, DisposableStore } from '../../../base/common/lifecycle.js';
+import { getActiveElement, isAncestorOfActiveElement, getWindow, addDisposableListener, isAncestor, EventType } from '../../../base/browser/dom.js';
+import { IKeybindingService } from '../../../platform/keybinding/common/keybinding.js';
+import { StandardKeyboardEvent } from '../../../base/browser/keyboardEvent.js';
+import { IAccessibilityService } from '../../../platform/accessibility/common/accessibility.js';
+import { ILayoutService } from '../../../platform/layout/browser/layoutService.js';
+import { mainWindow } from '../../../base/browser/window.js';
+let HoverService = class HoverService {
+    constructor(_instantiationService, _contextViewService, contextMenuService, _keybindingService, _layoutService, _accessibilityService) {
+        this._instantiationService = _instantiationService;
+        this._contextViewService = _contextViewService;
+        this._keybindingService = _keybindingService;
+        this._layoutService = _layoutService;
+        this._accessibilityService = _accessibilityService;
+        contextMenuService.onDidShowContextMenu(() => this.hideHover());
+    }
+    showHover(options, focus, skipLastFocusedUpdate) {
+        if (getHoverOptionsIdentity(this._currentHoverOptions) === getHoverOptionsIdentity(options)) {
+            return undefined;
+        }
+        if (this._currentHover && this._currentHoverOptions?.persistence?.sticky) {
+            return undefined;
+        }
+        this._currentHoverOptions = options;
+        this._lastHoverOptions = options;
+        const trapFocus = options.trapFocus || this._accessibilityService.isScreenReaderOptimized();
+        const activeElement = getActiveElement();
+        if (!skipLastFocusedUpdate) {
+            if (trapFocus && activeElement) {
+                this._lastFocusedElementBeforeOpen = activeElement;
+            }
+            else {
+                this._lastFocusedElementBeforeOpen = undefined;
+            }
+        }
+        const hoverDisposables = ( new DisposableStore());
+        const hover = this._instantiationService.createInstance(HoverWidget, options);
+        if (options.persistence?.sticky) {
+            hover.isLocked = true;
+        }
+        hover.onDispose(() => {
+            const hoverWasFocused = this._currentHover?.domNode && isAncestorOfActiveElement(this._currentHover.domNode);
+            if (hoverWasFocused) {
+                this._lastFocusedElementBeforeOpen?.focus();
+            }
+            if (this._currentHoverOptions === options) {
+                this._currentHoverOptions = undefined;
+            }
+            hoverDisposables.dispose();
+        });
+        if (!options.container) {
+            const targetElement = options.target instanceof HTMLElement ? options.target : options.target.targetElements[0];
+            options.container = this._layoutService.getContainer(getWindow(targetElement));
+        }
+        const provider = this._contextViewService;
+        provider.showContextView(( new HoverContextViewDelegate(hover, focus)), options.container);
+        hover.onRequestLayout(() => provider.layout());
+        if (options.persistence?.sticky) {
+            hoverDisposables.add(addDisposableListener(getWindow(options.container).document, EventType.MOUSE_DOWN, e => {
+                if (!isAncestor(e.target, hover.domNode)) {
+                    this.doHideHover();
+                }
+            }));
+        }
+        else {
+            if ('targetElements' in options.target) {
+                for (const element of options.target.targetElements) {
+                    hoverDisposables.add(addDisposableListener(element, EventType.CLICK, () => this.hideHover()));
+                }
+            }
+            else {
+                hoverDisposables.add(addDisposableListener(options.target, EventType.CLICK, () => this.hideHover()));
+            }
+            const focusedElement = getActiveElement();
+            if (focusedElement) {
+                const focusedElementDocument = getWindow(focusedElement).document;
+                hoverDisposables.add(addDisposableListener(focusedElement, EventType.KEY_DOWN, e => this._keyDown(e, hover, !!options.persistence?.hideOnKeyDown)));
+                hoverDisposables.add(addDisposableListener(focusedElementDocument, EventType.KEY_DOWN, e => this._keyDown(e, hover, !!options.persistence?.hideOnKeyDown)));
+                hoverDisposables.add(addDisposableListener(focusedElement, EventType.KEY_UP, e => this._keyUp(e, hover)));
+                hoverDisposables.add(addDisposableListener(focusedElementDocument, EventType.KEY_UP, e => this._keyUp(e, hover)));
+            }
+        }
+        if ('IntersectionObserver' in mainWindow) {
+            const observer = ( new IntersectionObserver(e => this._intersectionChange(e, hover), { threshold: 0 }));
+            const firstTargetElement = 'targetElements' in options.target ? options.target.targetElements[0] : options.target;
+            observer.observe(firstTargetElement);
+            hoverDisposables.add(toDisposable(() => observer.disconnect()));
+        }
+        this._currentHover = hover;
+        return hover;
+    }
+    hideHover() {
+        if (this._currentHover?.isLocked || !this._currentHoverOptions) {
+            return;
+        }
+        this.doHideHover();
+    }
+    doHideHover() {
+        this._currentHover = undefined;
+        this._currentHoverOptions = undefined;
+        this._contextViewService.hideContextView();
+    }
+    _intersectionChange(entries, hover) {
+        const entry = entries[entries.length - 1];
+        if (!entry.isIntersecting) {
+            hover.dispose();
+        }
+    }
+    showAndFocusLastHover() {
+        if (!this._lastHoverOptions) {
+            return;
+        }
+        this.showHover(this._lastHoverOptions, true, true);
+    }
+    _keyDown(e, hover, hideOnKeyDown) {
+        if (e.key === 'Alt') {
+            hover.isLocked = true;
+            return;
+        }
+        const event = ( new StandardKeyboardEvent(e));
+        const keybinding = this._keybindingService.resolveKeyboardEvent(event);
+        if (( keybinding.getSingleModifierDispatchChords().some(value => !!value)) || this._keybindingService.softDispatch(event, event.target).kind !== 0 ) {
+            return;
+        }
+        if (hideOnKeyDown && (!this._currentHoverOptions?.trapFocus || e.key !== 'Tab')) {
+            this.hideHover();
+            this._lastFocusedElementBeforeOpen?.focus();
+        }
+    }
+    _keyUp(e, hover) {
+        if (e.key === 'Alt') {
+            hover.isLocked = false;
+            if (!hover.isMouseIn) {
+                this.hideHover();
+                this._lastFocusedElementBeforeOpen?.focus();
+            }
+        }
+    }
+};
+HoverService = ( __decorate([
+    ( __param(0, IInstantiationService)),
+    ( __param(1, IContextViewService)),
+    ( __param(2, IContextMenuService)),
+    ( __param(3, IKeybindingService)),
+    ( __param(4, ILayoutService)),
+    ( __param(5, IAccessibilityService))
+], HoverService));
+function getHoverOptionsIdentity(options) {
+    if (options === undefined) {
+        return undefined;
+    }
+    return options?.id ?? options;
+}
+class HoverContextViewDelegate {
+    get anchorPosition() {
+        return this._hover.anchor;
+    }
+    constructor(_hover, _focus = false) {
+        this._hover = _hover;
+        this._focus = _focus;
+    }
+    render(container) {
+        this._hover.render(container);
+        if (this._focus) {
+            this._hover.focus();
+        }
+        return this._hover;
+    }
+    getAnchor() {
+        return {
+            x: this._hover.x,
+            y: this._hover.y
+        };
+    }
+    layout() {
+        this._hover.layout();
+    }
+}
+registerSingleton(IHoverService, HoverService, 1 );
+registerThemingParticipant((theme, collector) => {
+    const hoverBorder = theme.getColor(editorHoverBorder);
+    if (hoverBorder) {
+        collector.addRule(`.monaco-workbench .workbench-hover .hover-row:not(:first-child):not(:empty) { border-top: 1px solid ${( hoverBorder.transparent(0.5))}; }`);
+        collector.addRule(`.monaco-workbench .workbench-hover hr { border-top: 1px solid ${( hoverBorder.transparent(0.5))}; }`);
+    }
+});
+export { HoverService };

package/vscode/src/vs/editor/browser/view.js

@@ -1,19 +1,22 @@
 import { __decorate, __param } from '../../../../../external/tslib/tslib.es6.js';
 import { runAtThisOrScheduleAtNextAnimationFrame, getWindow } from '../../base/browser/dom.js';
-import { Selection } from '../common/core/selection.js';
-import { Range } from '../common/core/range.js';
 import { createFastDomNode } from '../../base/browser/fastDomNode.js';
+import { inputLatency } from '../../base/browser/performance.js';
 import { BugIndicatingError, onUnexpectedError } from '../../base/common/errors.js';
+import { PointerHandlerLastRenderData } from './controller/mouseTarget.js';
 import { PointerHandler } from './controller/pointerHandler.js';
 import { TextAreaHandler } from './controller/textAreaHandler.js';
+import { RenderingContext } from './view/renderingContext.js';
 import { ViewController } from './view/viewController.js';
-import { ViewUserInputEvents } from './view/viewUserInputEvents.js';
 import { ContentViewOverlays, MarginViewOverlays } from './view/viewOverlays.js';
 import { PartFingerprints } from './view/viewPart.js';
+import { ViewUserInputEvents } from './view/viewUserInputEvents.js';
+import { BlockDecorations } from './viewParts/blockDecorations/blockDecorations.js';
 import { ViewContentWidgets } from './viewParts/contentWidgets/contentWidgets.js';
 import { CurrentLineHighlightOverlay, CurrentLineMarginHighlightOverlay } from './viewParts/currentLineHighlight/currentLineHighlight.js';
 import { DecorationsOverlay } from './viewParts/decorations/decorations.js';
 import { EditorScrollbar } from './viewParts/editorScrollbar/editorScrollbar.js';
+import { GlyphMarginWidgets } from './viewParts/glyphMargin/glyphMargin.js';
 import { IndentGuidesOverlay } from './viewParts/indentGuides/indentGuides.js';
 import { LineNumbersOverlay } from './viewParts/lineNumbers/lineNumbers.js';
 import { ViewLines } from './viewParts/lines/viewLines.js';
@@ -29,19 +32,16 @@ import { ScrollDecorationViewPart } from './viewParts/scrollDecoration/scrollDec
 import { SelectionsOverlay } from './viewParts/selections/selections.js';
 import { ViewCursors } from './viewParts/viewCursors/viewCursors.js';
 import { ViewZones } from './viewParts/viewZones/viewZones.js';
-import { Position } from '../common/core/position.js';
-import { RenderingContext } from './view/renderingContext.js';
-import { ViewContext } from '../common/viewModel/viewContext.js';
-import { ViewportData } from '../common/viewLayout/viewLinesViewportData.js';
-import { ViewEventHandler } from '../common/viewEventHandler.js';
-import { getThemeTypeSelector } from '../../platform/theme/common/themeService.js';
-import { PointerHandlerLastRenderData } from './controller/mouseTarget.js';
-import { BlockDecorations } from './viewParts/blockDecorations/blockDecorations.js';
-import { inputLatency } from '../../base/browser/performance.js';
 import { WhitespaceOverlay } from './viewParts/whitespace/whitespace.js';
-import { GlyphMarginWidgets } from './viewParts/glyphMargin/glyphMargin.js';
+import { Position } from '../common/core/position.js';
+import { Range } from '../common/core/range.js';
+import { Selection } from '../common/core/selection.js';
 import { GlyphMarginLane } from '../common/model.js';
+import { ViewEventHandler } from '../common/viewEventHandler.js';
+import { ViewportData } from '../common/viewLayout/viewLinesViewportData.js';
+import { ViewContext } from '../common/viewModel/viewContext.js';
 import { IInstantiationService } from '../../platform/instantiation/common/instantiation.js';
+import { getThemeTypeSelector } from '../../platform/theme/common/themeService.js';
 let View = class View extends ViewEventHandler {
     constructor(commandDelegate, configuration, colorTheme, model, userInputEvents, overflowWidgetsDomNode, _instantiationService) {
         super();
@@ -102,7 +102,7 @@ let View = class View extends ViewEventHandler {
         this._viewParts.push(this._contentWidgets);
         this._viewCursors = ( new ViewCursors(this._context));
         this._viewParts.push(this._viewCursors);
-        this._overlayWidgets = ( new ViewOverlayWidgets(this._context));
+        this._overlayWidgets = ( new ViewOverlayWidgets(this._context, this.domNode));
         this._viewParts.push(this._overlayWidgets);
         const rulers = ( new Rulers(this._context));
         this._viewParts.push(rulers);
@@ -131,47 +131,36 @@ let View = class View extends ViewEventHandler {
         this.domNode.appendChild(this._overflowGuardContainer);
         if (overflowWidgetsDomNode) {
             overflowWidgetsDomNode.appendChild(this._contentWidgets.overflowingContentWidgetsDomNode.domNode);
+            overflowWidgetsDomNode.appendChild(this._overlayWidgets.overflowingOverlayWidgetsDomNode.domNode);
         }
         else {
             this.domNode.appendChild(this._contentWidgets.overflowingContentWidgetsDomNode);
+            this.domNode.appendChild(this._overlayWidgets.overflowingOverlayWidgetsDomNode);
         }
         this._applyLayout();
         this._pointerHandler = this._register(( new PointerHandler(this._context, viewController, this._createPointerHandlerHelper())));
     }
-    _computeGlyphMarginLaneCount() {
+    _computeGlyphMarginLanes() {
         const model = this._context.viewModel.model;
+        const laneModel = this._context.viewModel.glyphLanes;
         let glyphs = [];
+        let maxLineNumber = 0;
         glyphs = glyphs.concat(( model.getAllMarginDecorations().map((decoration) => {
-            const lane = decoration.options.glyphMargin?.position ?? GlyphMarginLane.Left;
-            return { range: decoration.range, lane };
+            const lane = decoration.options.glyphMargin?.position ?? GlyphMarginLane.Center;
+            maxLineNumber = Math.max(maxLineNumber, decoration.range.endLineNumber);
+            return { range: decoration.range, lane, persist: decoration.options.glyphMargin?.persistLane };
         })));
         glyphs = glyphs.concat(( this._glyphMarginWidgets.getWidgets().map((widget) => {
             const range = model.validateRange(widget.preference.range);
+            maxLineNumber = Math.max(maxLineNumber, range.endLineNumber);
             return { range, lane: widget.preference.lane };
         })));
         glyphs.sort((a, b) => Range.compareRangesUsingStarts(a.range, b.range));
-        let leftDecRange = null;
-        let rightDecRange = null;
-        for (const decoration of glyphs) {
-            if (decoration.lane === GlyphMarginLane.Left && (!leftDecRange || Range.compareRangesUsingEnds(leftDecRange, decoration.range) < 0)) {
-                leftDecRange = decoration.range;
-            }
-            if (decoration.lane === GlyphMarginLane.Right && (!rightDecRange || Range.compareRangesUsingEnds(rightDecRange, decoration.range) < 0)) {
-                rightDecRange = decoration.range;
-            }
-            if (leftDecRange && rightDecRange) {
-                if (leftDecRange.endLineNumber < rightDecRange.startLineNumber) {
-                    leftDecRange = null;
-                    continue;
-                }
-                if (rightDecRange.endLineNumber < leftDecRange.startLineNumber) {
-                    rightDecRange = null;
-                    continue;
-                }
-                return 2;
-            }
+        laneModel.reset(maxLineNumber);
+        for (const glyph of glyphs) {
+            laneModel.push(glyph.lane, glyph.range, glyph.persist);
         }
-        return 1;
+        return laneModel;
     }
     _createPointerHandlerHelper() {
         return {
@@ -340,7 +329,8 @@ let View = class View extends ViewEventHandler {
             prepareRenderText: () => {
                 if (this._shouldRecomputeGlyphMarginLanes) {
                     this._shouldRecomputeGlyphMarginLanes = false;
-                    this._context.configuration.setGlyphMarginDecorationLaneCount(this._computeGlyphMarginLaneCount());
+                    const model = this._computeGlyphMarginLanes();
+                    this._context.configuration.setGlyphMarginDecorationLaneCount(model.requiredLanes);
                 }
                 inputLatency.onRenderStart();
             },

package/vscode/src/vs/editor/browser/viewParts/currentLineHighlight/currentLineHighlight.js

@@ -5,6 +5,7 @@ import { equals } from '../../../../base/common/arrays.js';
 import { registerThemingParticipant } from '../../../../platform/theme/common/themeService.js';
 import { Selection } from '../../../common/core/selection.js';
 import { isHighContrast } from '../../../../platform/theme/common/theme.js';
+import { Position } from '../../../common/core/position.js';
 class AbstractLineHighlightOverlay extends DynamicViewOverlay {
     constructor(context) {
         super();
@@ -14,6 +15,7 @@ class AbstractLineHighlightOverlay extends DynamicViewOverlay {
         this._lineHeight = options.get(66 );
         this._renderLineHighlight = options.get(95 );
         this._renderLineHighlightOnlyWhenFocus = options.get(96 );
+        this._wordWrap = layoutInfo.isViewportWrapping;
         this._contentLeft = layoutInfo.contentLeft;
         this._contentWidth = layoutInfo.contentWidth;
         this._selectionIsEmpty = true;
@@ -29,7 +31,11 @@ class AbstractLineHighlightOverlay extends DynamicViewOverlay {
     }
     _readFromSelections() {
         let hasChanged = false;
-        const cursorsLineNumbers = ( this._selections.map(s => s.positionLineNumber));
+        const lineNumbers = ( new Set());
+        for (const selection of this._selections) {
+            lineNumbers.add(selection.positionLineNumber);
+        }
+        const cursorsLineNumbers = Array.from(lineNumbers);
         cursorsLineNumbers.sort((a, b) => a - b);
         if (!equals(this._cursorLineNumbers, cursorsLineNumbers)) {
             this._cursorLineNumbers = cursorsLineNumbers;
@@ -51,6 +57,7 @@ class AbstractLineHighlightOverlay extends DynamicViewOverlay {
         this._lineHeight = options.get(66 );
         this._renderLineHighlight = options.get(95 );
         this._renderLineHighlightOnlyWhenFocus = options.get(96 );
+        this._wordWrap = layoutInfo.isViewportWrapping;
         this._contentLeft = layoutInfo.contentLeft;
         this._contentWidth = layoutInfo.contentWidth;
         return true;
@@ -86,23 +93,38 @@ class AbstractLineHighlightOverlay extends DynamicViewOverlay {
             this._renderData = null;
             return;
         }
-        const renderedLine = this._renderOne(ctx);
         const visibleStartLineNumber = ctx.visibleRange.startLineNumber;
         const visibleEndLineNumber = ctx.visibleRange.endLineNumber;
-        const len = this._cursorLineNumbers.length;
-        let index = 0;
         const renderData = [];
         for (let lineNumber = visibleStartLineNumber; lineNumber <= visibleEndLineNumber; lineNumber++) {
             const lineIndex = lineNumber - visibleStartLineNumber;
-            while (index < len && this._cursorLineNumbers[index] < lineNumber) {
-                index++;
-            }
-            if (index < len && this._cursorLineNumbers[index] === lineNumber) {
-                renderData[lineIndex] = renderedLine;
+            renderData[lineIndex] = '';
+        }
+        if (this._wordWrap) {
+            const renderedLineWrapped = this._renderOne(ctx, false);
+            for (const cursorLineNumber of this._cursorLineNumbers) {
+                const coordinatesConverter = this._context.viewModel.coordinatesConverter;
+                const modelLineNumber = coordinatesConverter.convertViewPositionToModelPosition(( new Position(cursorLineNumber, 1))).lineNumber;
+                const firstViewLineNumber = coordinatesConverter.convertModelPositionToViewPosition(( new Position(modelLineNumber, 1))).lineNumber;
+                const lastViewLineNumber = coordinatesConverter.convertModelPositionToViewPosition(( new Position(
+                    modelLineNumber,
+                    this._context.viewModel.model.getLineMaxColumn(modelLineNumber)
+                ))).lineNumber;
+                const firstLine = Math.max(firstViewLineNumber, visibleStartLineNumber);
+                const lastLine = Math.min(lastViewLineNumber, visibleEndLineNumber);
+                for (let lineNumber = firstLine; lineNumber <= lastLine; lineNumber++) {
+                    const lineIndex = lineNumber - visibleStartLineNumber;
+                    renderData[lineIndex] = renderedLineWrapped;
+                }
             }
-            else {
-                renderData[lineIndex] = '';
+        }
+        const renderedLineExact = this._renderOne(ctx, true);
+        for (const cursorLineNumber of this._cursorLineNumbers) {
+            if (cursorLineNumber < visibleStartLineNumber || cursorLineNumber > visibleEndLineNumber) {
+                continue;
             }
+            const lineIndex = cursorLineNumber - visibleStartLineNumber;
+            renderData[lineIndex] = renderedLineExact;
         }
         this._renderData = renderData;
     }
@@ -127,8 +149,8 @@ class AbstractLineHighlightOverlay extends DynamicViewOverlay {
     }
 }
 class CurrentLineHighlightOverlay extends AbstractLineHighlightOverlay {
-    _renderOne(ctx) {
-        const className = 'current-line' + (this._shouldRenderOther() ? ' current-line-both' : '');
+    _renderOne(ctx, exact) {
+        const className = 'current-line' + (this._shouldRenderInMargin() ? ' current-line-both' : '') + (exact ? ' current-line-exact' : '');
         return `<div class="${className}" style="width:${Math.max(ctx.scrollWidth, this._contentWidth)}px; height:${this._lineHeight}px;"></div>`;
     }
     _shouldRenderThis() {
@@ -139,8 +161,8 @@ class CurrentLineHighlightOverlay extends AbstractLineHighlightOverlay {
     }
 }
 class CurrentLineMarginHighlightOverlay extends AbstractLineHighlightOverlay {
-    _renderOne(ctx) {
-        const className = 'current-line' + (this._shouldRenderInMargin() ? ' current-line-margin' : '') + (this._shouldRenderOther() ? ' current-line-margin-both' : '');
+    _renderOne(ctx, exact) {
+        const className = 'current-line' + (this._shouldRenderInMargin() ? ' current-line-margin' : '') + (this._shouldRenderOther() ? ' current-line-margin-both' : '') + (this._shouldRenderInMargin() && exact ? ' current-line-exact-margin' : '');
         return `<div class="${className}" style="width:${this._contentLeft}px; height:${this._lineHeight}px;"></div>`;
     }
     _shouldRenderThis() {
@@ -159,11 +181,11 @@ registerThemingParticipant((theme, collector) => {
     if (!lineHighlight || lineHighlight.isTransparent() || theme.defines(editorLineHighlightBorder)) {
         const lineHighlightBorder = theme.getColor(editorLineHighlightBorder);
         if (lineHighlightBorder) {
-            collector.addRule(`.monaco-editor .view-overlays .current-line { border: 2px solid ${lineHighlightBorder}; }`);
-            collector.addRule(`.monaco-editor .margin-view-overlays .current-line-margin { border: 2px solid ${lineHighlightBorder}; }`);
+            collector.addRule(`.monaco-editor .view-overlays .current-line-exact { border: 2px solid ${lineHighlightBorder}; }`);
+            collector.addRule(`.monaco-editor .margin-view-overlays .current-line-exact-margin { border: 2px solid ${lineHighlightBorder}; }`);
             if (isHighContrast(theme.type)) {
-                collector.addRule(`.monaco-editor .view-overlays .current-line { border-width: 1px; }`);
-                collector.addRule(`.monaco-editor .margin-view-overlays .current-line-margin { border-width: 1px; }`);
+                collector.addRule(`.monaco-editor .view-overlays .current-line-exact { border-width: 1px; }`);
+                collector.addRule(`.monaco-editor .margin-view-overlays .current-line-exact-margin { border-width: 1px; }`);
             }
         }
     }

package/vscode/src/vs/editor/browser/viewParts/editorScrollbar/editorScrollbar.js

@@ -37,7 +37,7 @@ class EditorScrollbar extends ViewPart {
             scrollbarOptions,
             this._context.viewLayout.getScrollable()
         )));
-        PartFingerprints.write(this.scrollbar.getDomNode(), 5 );
+        PartFingerprints.write(this.scrollbar.getDomNode(), 6 );
         this.scrollbarDomNode = createFastDomNode(this.scrollbar.getDomNode());
         this.scrollbarDomNode.setPosition('absolute');
         this._setLayout();

package/vscode/src/vs/editor/browser/viewParts/glyphMargin/glyphMargin.js

@@ -3,20 +3,24 @@ import { ArrayQueue } from '../../../../base/common/arrays.js';
 import './glyphMargin.css.js';
 import { DynamicViewOverlay } from '../../view/dynamicViewOverlay.js';
 import { ViewPart } from '../../view/viewPart.js';
+import { Position } from '../../../common/core/position.js';
 import { Range } from '../../../common/core/range.js';
+import { GlyphMarginLane } from '../../../common/model.js';
 class DecorationToRender {
-    constructor(startLineNumber, endLineNumber, className, zIndex) {
+    constructor(startLineNumber, endLineNumber, className, tooltip, zIndex) {
+        this.startLineNumber = startLineNumber;
+        this.endLineNumber = endLineNumber;
+        this.className = className;
+        this.tooltip = tooltip;
         this._decorationToRenderBrand = undefined;
-        this.startLineNumber = +startLineNumber;
-        this.endLineNumber = +endLineNumber;
-        this.className = String(className);
         this.zIndex = zIndex ?? 0;
     }
 }
 class LineDecorationToRender {
-    constructor(className, zIndex) {
+    constructor(className, zIndex, tooltip) {
         this.className = className;
         this.zIndex = zIndex;
+        this.tooltip = tooltip;
     }
 }
 class VisibleLineDecorationsToRender {
@@ -66,7 +70,7 @@ class DedupOverlay extends DynamicViewOverlay {
                 prevEndLineIndex = endLineIndex;
             }
             for (let i = startLineIndex; i <= prevEndLineIndex; i++) {
-                output[i].add(( new LineDecorationToRender(className, zIndex)));
+                output[i].add(( new LineDecorationToRender(className, zIndex, d.tooltip)));
             }
         }
         return output;
@@ -177,10 +181,12 @@ class GlyphMarginWidgets extends ViewPart {
             }
             const startLineNumber = Math.max(d.range.startLineNumber, visibleStartLineNumber);
             const endLineNumber = Math.min(d.range.endLineNumber, visibleEndLineNumber);
-            const lane = Math.min(d.options.glyphMargin?.position ?? 1, this._glyphMarginDecorationLaneCount);
+            const lane = d.options.glyphMargin?.position ?? GlyphMarginLane.Center;
             const zIndex = d.options.zIndex ?? 0;
             for (let lineNumber = startLineNumber; lineNumber <= endLineNumber; lineNumber++) {
-                requests.push(( new DecorationBasedGlyphRenderRequest(lineNumber, lane, zIndex, glyphMarginClassName)));
+                const modelPosition = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(( new Position(lineNumber, 0)));
+                const laneIndex = this._context.viewModel.glyphLanes.getLanesAtLine(modelPosition.lineNumber).indexOf(lane);
+                requests.push(( new DecorationBasedGlyphRenderRequest(lineNumber, laneIndex, zIndex, glyphMarginClassName)));
             }
         }
     }
@@ -194,8 +200,9 @@ class GlyphMarginWidgets extends ViewPart {
                 continue;
             }
             const widgetLineNumber = Math.max(startLineNumber, visibleStartLineNumber);
-            const lane = Math.min(widget.preference.lane, this._glyphMarginDecorationLaneCount);
-            requests.push(( new WidgetBasedGlyphRenderRequest(widgetLineNumber, lane, widget.preference.zIndex, widget)));
+            const modelPosition = this._context.viewModel.coordinatesConverter.convertViewPositionToModelPosition(( new Position(widgetLineNumber, 0)));
+            const laneIndex = this._context.viewModel.glyphLanes.getLanesAtLine(modelPosition.lineNumber).indexOf(widget.preference.lane);
+            requests.push(( new WidgetBasedGlyphRenderRequest(widgetLineNumber, laneIndex, widget.preference.zIndex, widget)));
         }
     }
     _collectSortedGlyphRenderRequests(ctx) {
@@ -204,7 +211,7 @@ class GlyphMarginWidgets extends ViewPart {
         this._collectWidgetBasedGlyphRenderRequest(ctx, requests);
         requests.sort((a, b) => {
             if (a.lineNumber === b.lineNumber) {
-                if (a.lane === b.lane) {
+                if (a.laneIndex === b.laneIndex) {
                     if (a.zIndex === b.zIndex) {
                         if (b.type === a.type) {
                             if (a.type === 0  && b.type === 0 ) {
@@ -216,7 +223,7 @@ class GlyphMarginWidgets extends ViewPart {
                     }
                     return b.zIndex - a.zIndex;
                 }
-                return a.lane - b.lane;
+                return a.laneIndex - b.laneIndex;
             }
             return a.lineNumber - b.lineNumber;
         });
@@ -237,7 +244,7 @@ class GlyphMarginWidgets extends ViewPart {
             if (!first) {
                 break;
             }
-            const requestsAtLocation = requests.takeWhile((el) => el.lineNumber === first.lineNumber && el.lane === first.lane);
+            const requestsAtLocation = requests.takeWhile((el) => el.lineNumber === first.lineNumber && el.laneIndex === first.laneIndex);
             if (!requestsAtLocation || requestsAtLocation.length === 0) {
                 break;
             }
@@ -257,7 +264,7 @@ class GlyphMarginWidgets extends ViewPart {
             else {
                 winner.widget.renderInfo = {
                     lineNumber: winner.lineNumber,
-                    lane: winner.lane,
+                    laneIndex: winner.laneIndex,
                 };
             }
         }
@@ -281,7 +288,7 @@ class GlyphMarginWidgets extends ViewPart {
             }
             else {
                 const top = ctx.viewportData.relativeVerticalOffset[widget.renderInfo.lineNumber - ctx.viewportData.startLineNumber];
-                const left = this._glyphMarginLeft + (widget.renderInfo.lane - 1) * this._lineHeight;
+                const left = this._glyphMarginLeft + widget.renderInfo.laneIndex * this._lineHeight;
                 widget.domNode.setDisplay('block');
                 widget.domNode.setTop(top);
                 widget.domNode.setLeft(left);
@@ -292,7 +299,7 @@ class GlyphMarginWidgets extends ViewPart {
         for (let i = 0; i < this._decorationGlyphsToRender.length; i++) {
             const dec = this._decorationGlyphsToRender[i];
             const top = ctx.viewportData.relativeVerticalOffset[dec.lineNumber - ctx.viewportData.startLineNumber];
-            const left = this._glyphMarginLeft + (dec.lane - 1) * this._lineHeight;
+            const left = this._glyphMarginLeft + dec.laneIndex * this._lineHeight;
             let domNode;
             if (i < this._managedDomNodes.length) {
                 domNode = this._managedDomNodes[i];
@@ -316,30 +323,30 @@ class GlyphMarginWidgets extends ViewPart {
     }
 }
 class DecorationBasedGlyphRenderRequest {
-    constructor(lineNumber, lane, zIndex, className) {
+    constructor(lineNumber, laneIndex, zIndex, className) {
         this.lineNumber = lineNumber;
-        this.lane = lane;
+        this.laneIndex = laneIndex;
         this.zIndex = zIndex;
         this.className = className;
         this.type = 0 ;
     }
     accept(combinedClassName) {
-        return ( new DecorationBasedGlyph(this.lineNumber, this.lane, combinedClassName));
+        return ( new DecorationBasedGlyph(this.lineNumber, this.laneIndex, combinedClassName));
     }
 }
 class WidgetBasedGlyphRenderRequest {
-    constructor(lineNumber, lane, zIndex, widget) {
+    constructor(lineNumber, laneIndex, zIndex, widget) {
         this.lineNumber = lineNumber;
-        this.lane = lane;
+        this.laneIndex = laneIndex;
         this.zIndex = zIndex;
         this.widget = widget;
         this.type = 1 ;
     }
 }
 class DecorationBasedGlyph {
-    constructor(lineNumber, lane, combinedClassName) {
+    constructor(lineNumber, laneIndex, combinedClassName) {
         this.lineNumber = lineNumber;
-        this.lane = lane;
+        this.laneIndex = laneIndex;
         this.combinedClassName = combinedClassName;
     }
 }