monaco-editor11 1.0.7 → 1.0.9

package/dist/workers/editor/common/viewLayout.js

@@ -0,0 +1,368 @@
+import { Emitter } from '../../../base/common/event.js';
+import { Disposable } from '../../../base/common/lifecycle.js';
+import { Scrollable } from '../../../base/common/scrollable.js';
+import { LinesLayout } from './linesLayout.js';
+import { Viewport } from '../viewModel.js';
+import { ContentSizeChangedEvent } from '../viewModelEventDispatcher.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+const SMOOTH_SCROLLING_TIME = 125;
+class EditorScrollDimensions {
+    constructor(width, contentWidth, height, contentHeight) {
+        width = width | 0;
+        contentWidth = contentWidth | 0;
+        height = height | 0;
+        contentHeight = contentHeight | 0;
+        if (width < 0) {
+            width = 0;
+        }
+        if (contentWidth < 0) {
+            contentWidth = 0;
+        }
+        if (height < 0) {
+            height = 0;
+        }
+        if (contentHeight < 0) {
+            contentHeight = 0;
+        }
+        this.width = width;
+        this.contentWidth = contentWidth;
+        this.scrollWidth = Math.max(width, contentWidth);
+        this.height = height;
+        this.contentHeight = contentHeight;
+        this.scrollHeight = Math.max(height, contentHeight);
+    }
+    equals(other) {
+        return (this.width === other.width
+            && this.contentWidth === other.contentWidth
+            && this.height === other.height
+            && this.contentHeight === other.contentHeight);
+    }
+}
+class EditorScrollable extends Disposable {
+    constructor(smoothScrollDuration, scheduleAtNextAnimationFrame) {
+        super();
+        this._onDidContentSizeChange = this._register(new Emitter());
+        this.onDidContentSizeChange = this._onDidContentSizeChange.event;
+        this._dimensions = new EditorScrollDimensions(0, 0, 0, 0);
+        this._scrollable = this._register(new Scrollable({
+            forceIntegerValues: true,
+            smoothScrollDuration,
+            scheduleAtNextAnimationFrame
+        }));
+        this.onDidScroll = this._scrollable.onScroll;
+    }
+    getScrollable() {
+        return this._scrollable;
+    }
+    setSmoothScrollDuration(smoothScrollDuration) {
+        this._scrollable.setSmoothScrollDuration(smoothScrollDuration);
+    }
+    validateScrollPosition(scrollPosition) {
+        return this._scrollable.validateScrollPosition(scrollPosition);
+    }
+    getScrollDimensions() {
+        return this._dimensions;
+    }
+    setScrollDimensions(dimensions) {
+        if (this._dimensions.equals(dimensions)) {
+            return;
+        }
+        const oldDimensions = this._dimensions;
+        this._dimensions = dimensions;
+        this._scrollable.setScrollDimensions({
+            width: dimensions.width,
+            scrollWidth: dimensions.scrollWidth,
+            height: dimensions.height,
+            scrollHeight: dimensions.scrollHeight
+        }, true);
+        const contentWidthChanged = (oldDimensions.contentWidth !== dimensions.contentWidth);
+        const contentHeightChanged = (oldDimensions.contentHeight !== dimensions.contentHeight);
+        if (contentWidthChanged || contentHeightChanged) {
+            this._onDidContentSizeChange.fire(new ContentSizeChangedEvent(oldDimensions.contentWidth, oldDimensions.contentHeight, dimensions.contentWidth, dimensions.contentHeight));
+        }
+    }
+    getFutureScrollPosition() {
+        return this._scrollable.getFutureScrollPosition();
+    }
+    getCurrentScrollPosition() {
+        return this._scrollable.getCurrentScrollPosition();
+    }
+    setScrollPositionNow(update) {
+        this._scrollable.setScrollPositionNow(update);
+    }
+    setScrollPositionSmooth(update) {
+        this._scrollable.setScrollPositionSmooth(update);
+    }
+    hasPendingScrollAnimation() {
+        return this._scrollable.hasPendingScrollAnimation();
+    }
+}
+class ViewLayout extends Disposable {
+    constructor(configuration, lineCount, customLineHeightData, scheduleAtNextAnimationFrame) {
+        super();
+        this._configuration = configuration;
+        const options = this._configuration.options;
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        const padding = options.get(96 /* EditorOption.padding */);
+        this._linesLayout = new LinesLayout(lineCount, options.get(75 /* EditorOption.lineHeight */), padding.top, padding.bottom, customLineHeightData);
+        this._maxLineWidth = 0;
+        this._overlayWidgetsMinWidth = 0;
+        this._scrollable = this._register(new EditorScrollable(0, scheduleAtNextAnimationFrame));
+        this._configureSmoothScrollDuration();
+        this._scrollable.setScrollDimensions(new EditorScrollDimensions(layoutInfo.contentWidth, 0, layoutInfo.height, 0));
+        this.onDidScroll = this._scrollable.onDidScroll;
+        this.onDidContentSizeChange = this._scrollable.onDidContentSizeChange;
+        this._updateHeight();
+    }
+    dispose() {
+        super.dispose();
+    }
+    getScrollable() {
+        return this._scrollable.getScrollable();
+    }
+    onHeightMaybeChanged() {
+        this._updateHeight();
+    }
+    _configureSmoothScrollDuration() {
+        this._scrollable.setSmoothScrollDuration(this._configuration.options.get(130 /* EditorOption.smoothScrolling */) ? SMOOTH_SCROLLING_TIME : 0);
+    }
+    // ---- begin view event handlers
+    onConfigurationChanged(e) {
+        const options = this._configuration.options;
+        if (e.hasChanged(75 /* EditorOption.lineHeight */)) {
+            this._linesLayout.setDefaultLineHeight(options.get(75 /* EditorOption.lineHeight */));
+        }
+        if (e.hasChanged(96 /* EditorOption.padding */)) {
+            const padding = options.get(96 /* EditorOption.padding */);
+            this._linesLayout.setPadding(padding.top, padding.bottom);
+        }
+        if (e.hasChanged(165 /* EditorOption.layoutInfo */)) {
+            const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+            const width = layoutInfo.contentWidth;
+            const height = layoutInfo.height;
+            const scrollDimensions = this._scrollable.getScrollDimensions();
+            const contentWidth = scrollDimensions.contentWidth;
+            this._scrollable.setScrollDimensions(new EditorScrollDimensions(width, scrollDimensions.contentWidth, height, this._getContentHeight(width, height, contentWidth)));
+        }
+        else {
+            this._updateHeight();
+        }
+        if (e.hasChanged(130 /* EditorOption.smoothScrolling */)) {
+            this._configureSmoothScrollDuration();
+        }
+    }
+    onFlushed(lineCount, customLineHeightData) {
+        this._linesLayout.onFlushed(lineCount, customLineHeightData);
+    }
+    onLinesDeleted(fromLineNumber, toLineNumber) {
+        this._linesLayout.onLinesDeleted(fromLineNumber, toLineNumber);
+    }
+    onLinesInserted(fromLineNumber, toLineNumber) {
+        this._linesLayout.onLinesInserted(fromLineNumber, toLineNumber);
+    }
+    // ---- end view event handlers
+    _getHorizontalScrollbarHeight(width, scrollWidth) {
+        const options = this._configuration.options;
+        const scrollbar = options.get(117 /* EditorOption.scrollbar */);
+        if (scrollbar.horizontal === 2 /* ScrollbarVisibility.Hidden */) {
+            // horizontal scrollbar not visible
+            return 0;
+        }
+        if (width >= scrollWidth) {
+            // horizontal scrollbar not visible
+            return 0;
+        }
+        return scrollbar.horizontalScrollbarSize;
+    }
+    _getContentHeight(width, height, contentWidth) {
+        const options = this._configuration.options;
+        let result = this._linesLayout.getLinesTotalHeight();
+        if (options.get(119 /* EditorOption.scrollBeyondLastLine */)) {
+            result += Math.max(0, height - options.get(75 /* EditorOption.lineHeight */) - options.get(96 /* EditorOption.padding */).bottom);
+        }
+        else if (!options.get(117 /* EditorOption.scrollbar */).ignoreHorizontalScrollbarInContentHeight) {
+            result += this._getHorizontalScrollbarHeight(width, contentWidth);
+        }
+        return result;
+    }
+    _updateHeight() {
+        const scrollDimensions = this._scrollable.getScrollDimensions();
+        const width = scrollDimensions.width;
+        const height = scrollDimensions.height;
+        const contentWidth = scrollDimensions.contentWidth;
+        this._scrollable.setScrollDimensions(new EditorScrollDimensions(width, scrollDimensions.contentWidth, height, this._getContentHeight(width, height, contentWidth)));
+    }
+    // ---- Layouting logic
+    getCurrentViewport() {
+        const scrollDimensions = this._scrollable.getScrollDimensions();
+        const currentScrollPosition = this._scrollable.getCurrentScrollPosition();
+        return new Viewport(currentScrollPosition.scrollTop, currentScrollPosition.scrollLeft, scrollDimensions.width, scrollDimensions.height);
+    }
+    getFutureViewport() {
+        const scrollDimensions = this._scrollable.getScrollDimensions();
+        const currentScrollPosition = this._scrollable.getFutureScrollPosition();
+        return new Viewport(currentScrollPosition.scrollTop, currentScrollPosition.scrollLeft, scrollDimensions.width, scrollDimensions.height);
+    }
+    _computeContentWidth() {
+        const options = this._configuration.options;
+        const maxLineWidth = this._maxLineWidth;
+        const wrappingInfo = options.get(166 /* EditorOption.wrappingInfo */);
+        const fontInfo = options.get(59 /* EditorOption.fontInfo */);
+        const layoutInfo = options.get(165 /* EditorOption.layoutInfo */);
+        if (wrappingInfo.isViewportWrapping) {
+            const minimap = options.get(81 /* EditorOption.minimap */);
+            if (maxLineWidth > layoutInfo.contentWidth + fontInfo.typicalHalfwidthCharacterWidth) {
+                // This is a case where viewport wrapping is on, but the line extends above the viewport
+                if (minimap.enabled && minimap.side === 'right') {
+                    // We need to accomodate the scrollbar width
+                    return maxLineWidth + layoutInfo.verticalScrollbarWidth;
+                }
+            }
+            return maxLineWidth;
+        }
+        else {
+            const extraHorizontalSpace = options.get(118 /* EditorOption.scrollBeyondLastColumn */) * fontInfo.typicalHalfwidthCharacterWidth;
+            const whitespaceMinWidth = this._linesLayout.getWhitespaceMinWidth();
+            return Math.max(maxLineWidth + extraHorizontalSpace + layoutInfo.verticalScrollbarWidth, whitespaceMinWidth, this._overlayWidgetsMinWidth);
+        }
+    }
+    setMaxLineWidth(maxLineWidth) {
+        this._maxLineWidth = maxLineWidth;
+        this._updateContentWidth();
+    }
+    setOverlayWidgetsMinWidth(maxMinWidth) {
+        this._overlayWidgetsMinWidth = maxMinWidth;
+        this._updateContentWidth();
+    }
+    _updateContentWidth() {
+        const scrollDimensions = this._scrollable.getScrollDimensions();
+        this._scrollable.setScrollDimensions(new EditorScrollDimensions(scrollDimensions.width, this._computeContentWidth(), scrollDimensions.height, scrollDimensions.contentHeight));
+        // The height might depend on the fact that there is a horizontal scrollbar or not
+        this._updateHeight();
+    }
+    // ---- view state
+    saveState() {
+        const currentScrollPosition = this._scrollable.getFutureScrollPosition();
+        const scrollTop = currentScrollPosition.scrollTop;
+        const firstLineNumberInViewport = this._linesLayout.getLineNumberAtOrAfterVerticalOffset(scrollTop);
+        const whitespaceAboveFirstLine = this._linesLayout.getWhitespaceAccumulatedHeightBeforeLineNumber(firstLineNumberInViewport);
+        return {
+            scrollTop: scrollTop,
+            scrollTopWithoutViewZones: scrollTop - whitespaceAboveFirstLine,
+            scrollLeft: currentScrollPosition.scrollLeft
+        };
+    }
+    // ----
+    changeWhitespace(callback) {
+        const hadAChange = this._linesLayout.changeWhitespace(callback);
+        if (hadAChange) {
+            this.onHeightMaybeChanged();
+        }
+        return hadAChange;
+    }
+    changeSpecialLineHeights(callback) {
+        const hadAChange = this._linesLayout.changeLineHeights(callback);
+        if (hadAChange) {
+            this.onHeightMaybeChanged();
+        }
+        return hadAChange;
+    }
+    getVerticalOffsetForLineNumber(lineNumber, includeViewZones = false) {
+        return this._linesLayout.getVerticalOffsetForLineNumber(lineNumber, includeViewZones);
+    }
+    getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones = false) {
+        return this._linesLayout.getVerticalOffsetAfterLineNumber(lineNumber, includeViewZones);
+    }
+    getLineHeightForLineNumber(lineNumber) {
+        return this._linesLayout.getLineHeightForLineNumber(lineNumber);
+    }
+    isAfterLines(verticalOffset) {
+        return this._linesLayout.isAfterLines(verticalOffset);
+    }
+    isInTopPadding(verticalOffset) {
+        return this._linesLayout.isInTopPadding(verticalOffset);
+    }
+    isInBottomPadding(verticalOffset) {
+        return this._linesLayout.isInBottomPadding(verticalOffset);
+    }
+    getLineNumberAtVerticalOffset(verticalOffset) {
+        return this._linesLayout.getLineNumberAtOrAfterVerticalOffset(verticalOffset);
+    }
+    getWhitespaceAtVerticalOffset(verticalOffset) {
+        return this._linesLayout.getWhitespaceAtVerticalOffset(verticalOffset);
+    }
+    getLinesViewportData() {
+        const visibleBox = this.getCurrentViewport();
+        return this._linesLayout.getLinesViewportData(visibleBox.top, visibleBox.top + visibleBox.height);
+    }
+    getLinesViewportDataAtScrollTop(scrollTop) {
+        // do some minimal validations on scrollTop
+        const scrollDimensions = this._scrollable.getScrollDimensions();
+        if (scrollTop + scrollDimensions.height > scrollDimensions.scrollHeight) {
+            scrollTop = scrollDimensions.scrollHeight - scrollDimensions.height;
+        }
+        if (scrollTop < 0) {
+            scrollTop = 0;
+        }
+        return this._linesLayout.getLinesViewportData(scrollTop, scrollTop + scrollDimensions.height);
+    }
+    getWhitespaceViewportData() {
+        const visibleBox = this.getCurrentViewport();
+        return this._linesLayout.getWhitespaceViewportData(visibleBox.top, visibleBox.top + visibleBox.height);
+    }
+    getWhitespaces() {
+        return this._linesLayout.getWhitespaces();
+    }
+    // ----
+    getContentWidth() {
+        const scrollDimensions = this._scrollable.getScrollDimensions();
+        return scrollDimensions.contentWidth;
+    }
+    getScrollWidth() {
+        const scrollDimensions = this._scrollable.getScrollDimensions();
+        return scrollDimensions.scrollWidth;
+    }
+    getContentHeight() {
+        const scrollDimensions = this._scrollable.getScrollDimensions();
+        return scrollDimensions.contentHeight;
+    }
+    getScrollHeight() {
+        const scrollDimensions = this._scrollable.getScrollDimensions();
+        return scrollDimensions.scrollHeight;
+    }
+    getCurrentScrollLeft() {
+        const currentScrollPosition = this._scrollable.getCurrentScrollPosition();
+        return currentScrollPosition.scrollLeft;
+    }
+    getCurrentScrollTop() {
+        const currentScrollPosition = this._scrollable.getCurrentScrollPosition();
+        return currentScrollPosition.scrollTop;
+    }
+    validateScrollPosition(scrollPosition) {
+        return this._scrollable.validateScrollPosition(scrollPosition);
+    }
+    setScrollPosition(position, type) {
+        if (type === 1 /* ScrollType.Immediate */) {
+            this._scrollable.setScrollPositionNow(position);
+        }
+        else {
+            this._scrollable.setScrollPositionSmooth(position);
+        }
+    }
+    hasPendingScrollAnimation() {
+        return this._scrollable.hasPendingScrollAnimation();
+    }
+    deltaScrollNow(deltaScrollLeft, deltaScrollTop) {
+        const currentScrollPosition = this._scrollable.getCurrentScrollPosition();
+        this._scrollable.setScrollPositionNow({
+            scrollLeft: currentScrollPosition.scrollLeft + deltaScrollLeft,
+            scrollTop: currentScrollPosition.scrollTop + deltaScrollTop
+        });
+    }
+}
+
+export { ViewLayout };