From 3b1bf65477697f446d0f6e994b28a99200f58eb7 Mon Sep 17 00:00:00 2001 From: Tobias Melcher Date: Mon, 16 Nov 2026 15:05:24 +0100 Subject: [PATCH] Keep compare borders aligned when line heights change Use SWT line coordinates to keep compare geometry aligned after scrolling while retaining the height cache. Validate populated entries before drawing, preserve entries before the first mismatching line and bypass the cache while widget metrics disagree. Add geometry and scrolling regressions to the Compare CI suite. Fixes #3076 --- .../contentmergeviewer/TextMergeViewer.java | 242 +++++++--- .../internal/IMergeViewerTestAdapter.java | 37 ++ .../compare/tests/AllCompareTests.java | 2 + .../tests/TextMergeViewerGeometryTest.java | 420 ++++++++++++++++++ .../TextMergeViewerScrollRegressionTest.java | 165 +++++++ 5 files changed, 810 insertions(+), 56 deletions(-) create mode 100644 team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerGeometryTest.java create mode 100644 team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerScrollRegressionTest.java diff --git a/team/bundles/org.eclipse.compare/compare/org/eclipse/compare/contentmergeviewer/TextMergeViewer.java b/team/bundles/org.eclipse.compare/compare/org/eclipse/compare/contentmergeviewer/TextMergeViewer.java index 7a41d53b058..5fc05a299a9 100644 --- a/team/bundles/org.eclipse.compare/compare/org/eclipse/compare/contentmergeviewer/TextMergeViewer.java +++ b/team/bundles/org.eclipse.compare/compare/org/eclipse/compare/contentmergeviewer/TextMergeViewer.java @@ -34,7 +34,8 @@ import java.lang.reflect.InvocationTargetException; import java.text.MessageFormat; import java.util.ArrayList; -import java.util.Collections; +import java.util.Arrays; +import java.util.BitSet; import java.util.HashMap; import java.util.Iterator; import java.util.List; @@ -473,7 +474,54 @@ public ColorPalette(RGB background, String registryKey, RGB defaultRGB) { // calling w.getLineHeight(line) + w.getLineSpacing() + // w.getLineVerticalIndent(line); again and again for the same line is too slow // we therefore introduce a line height cache by viewer - private final Map> lineHeightsByViewer = new HashMap<>(); + private final Map lineHeightsByViewer = new HashMap<>(); + + private static final class LineHeightCache { + private final Font font; + private final int baseHeight; + private final int spacing; + private final int[] heights; + private final int[] indents; + private final int[] cumulativeHeights; + private final BitSet populatedLines = new BitSet(); + private int prefixLines; + private int prefixHeight; + private boolean usable = true; + private int checkpointFrom; + private int checkpointTo; + private int checkpointHeight; + + private LineHeightCache(StyledText textWidget) { + font = textWidget.getFont(); + baseHeight = textWidget.getLineHeight(); + spacing = textWidget.getLineSpacing(); + heights = new int[textWidget.getLineCount()]; + indents = new int[heights.length]; + cumulativeHeights = new int[heights.length + 1]; + Arrays.fill(heights, -1); + } + + private boolean matches(StyledText textWidget) { + return !font.isDisposed() && font.equals(textWidget.getFont()) + && baseHeight == textWidget.getLineHeight() && spacing == textWidget.getLineSpacing() + && heights.length == textWidget.getLineCount(); + } + + private void invalidateFrom(int line) { + Arrays.fill(heights, line, heights.length, -1); + prefixLines = Math.min(line, prefixLines); + prefixHeight = cumulativeHeights[prefixLines]; + populatedLines.clear(line, heights.length); + usable = true; + } + + private void bypass(int fromLine, int toLine, int height) { + usable = false; + checkpointFrom = fromLine; + checkpointTo = toLine; + checkpointHeight = height; + } + } /** * Preference key for highlighting current line. @@ -2401,6 +2449,7 @@ private void setCurrentDiff2(Diff diff, boolean reveal) { } private Diff handleMouseInSides(Canvas canvas, MergeSourceViewer tp, int my) { + validateLineHeightCache(tp); int visibleHeight= tp.getViewportHeight(); @@ -2409,8 +2458,6 @@ private Diff handleMouseInSides(Canvas canvas, MergeSourceViewer tp, int my) { } if (fMerger.hasChanges()) { - int shift = calculateShift(tp) + (2 - LW); - Point region= new Point(0, 0); char leg = getLeg(tp); for (Iterator iterator = fMerger.changesIterator(); iterator.hasNext();) { @@ -2421,7 +2468,7 @@ private Diff handleMouseInSides(Canvas canvas, MergeSourceViewer tp, int my) { tp.getLineRange(diff.getPosition(leg), region); region.x -= tp.getDocumentRegionOffset(); - int y = getHeightBetweenLines(tp, 0, region.x) + shift; + int y = getLineY(tp, region.x) + (2 - LW); int h = getHeightBetweenLines(tp, region.x, region.x + region.y); if (y+h < 0) { @@ -2440,6 +2487,8 @@ private Diff handleMouseInSides(Canvas canvas, MergeSourceViewer tp, int my) { } private Diff getDiffUnderMouse(Canvas canvas, int mx, int my, Rectangle r) { + validateLineHeightCache(fLeft); + validateLineHeightCache(fRight); if (! fSynchronizedScrolling) { return null; @@ -2455,9 +2504,6 @@ private Diff getDiffUnderMouse(Canvas canvas, int mx, int my, Rectangle r) { } if (fMerger.hasChanges()) { - int lshift = calculateShift(fLeft); - int rshift = calculateShift(fRight); - Point region= new Point(0, 0); for (Iterator iterator = fMerger.changesIterator(); iterator.hasNext();) { @@ -2468,12 +2514,12 @@ private Diff getDiffUnderMouse(Canvas canvas, int mx, int my, Rectangle r) { fLeft.getLineRange(diff.getPosition(LEFT_CONTRIBUTOR), region); region.x -= fLeft.getDocumentRegionOffset(); - int ly = getHeightBetweenLines(fLeft, 0, region.x) + lshift; + int ly = getLineY(fLeft, region.x); int lh = getHeightBetweenLines(fLeft, region.x, region.x + region.y); fRight.getLineRange(diff.getPosition(RIGHT_CONTRIBUTOR), region); region.x -= fRight.getDocumentRegionOffset(); - int ry = getHeightBetweenLines(fRight, 0, region.x) + rshift; + int ry = getLineY(fRight, region.x); int rh = getHeightBetweenLines(fRight, region.x, region.x + region.y); if (Math.max(ly+lh, ry+rh) < 0) { @@ -2818,8 +2864,10 @@ private MergeSourceViewer createPart(Composite parent) { createSourceViewer(parent, getDirection()), getResourceBundle(), getCompareConfiguration().getContainer()); final StyledText te= viewer.getSourceViewer().getTextWidget(); + viewer.getSourceViewer().addTextListener(_ -> lineHeightsByViewer.remove(viewer)); + viewer.getSourceViewer().addTextPresentationListener(_ -> lineHeightsByViewer.remove(viewer)); // Clear cached line heights upon zoom changes, as they are no longer valid - te.addListener(SWT.ZoomChanged, _ -> resetCachedLineHeights(viewer)); + te.addListener(SWT.ZoomChanged, _ -> lineHeightsByViewer.remove(viewer)); if (!fConfirmSave) { viewer.hideSaveAction(); } @@ -4538,49 +4586,119 @@ private void updateLines(IDocument d) { * @param line * @return */ - private int getHeightBetweenLines(MergeSourceViewer tp, int fromLine, int toLine) { + int getHeightBetweenLines(MergeSourceViewer tp, int fromLine, int toLine) { if (fromLine == toLine) { return 0; } - StyledText w = tp.getSourceViewer().getTextWidget(); - List lineHeights = this.lineHeightsByViewer.get(tp); - if (lineHeights == null) { - lineHeights = new ArrayList<>(); - lineHeights.addAll(Collections.nCopies(w.getLineCount(), null)); - this.lineHeightsByViewer.put(tp, lineHeights); - tp.getSourceViewer().addTextListener(_ -> resetCachedLineHeights(tp)); - } - - int lineSpacing = w.getLineSpacing(); - + StyledText textWidget = tp.getSourceViewer().getTextWidget(); // If the linenumber is higher than the number of lines, we should prevent an // IndexOutOfBoundsException - if (toLine > w.getLineCount()){ - int lineHeight = tp.getSourceViewer().getTextWidget().getLineHeight(); - return (toLine - fromLine) * (lineHeight + w.getLineVerticalIndent(0)) + lineSpacing; + if (toLine > textWidget.getLineCount()) { + int lineHeight = textWidget.getLineHeight(); + return (toLine - fromLine) * (lineHeight + textWidget.getLineVerticalIndent(0)) + + textWidget.getLineSpacing(); } + if (canCacheLineHeights(textWidget)) { + LineHeightCache cache = lineHeightsByViewer.get(tp); + if (cache == null || !cache.matches(textWidget)) { + cache = new LineHeightCache(textWidget); + lineHeightsByViewer.put(tp, cache); + } + if (!cache.usable) { + return textWidget.getLinePixel(toLine) - textWidget.getLinePixel(fromLine); + } + if (toLine <= cache.prefixLines && fromLine <= toLine) { + return cache.cumulativeHeights[toLine] - cache.cumulativeHeights[fromLine]; + } + int height = 0; + boolean populated = false; + for (int line = fromLine; line < toLine; line++) { + if (cache.heights[line] < 0) { + cache.indents[line] = textWidget.getLineVerticalIndent(line); + cache.heights[line] = textWidget.getLineHeight(textWidget.getOffsetAtLine(line)) + + cache.spacing + cache.indents[line]; + cache.populatedLines.set(line); + populated = true; + } + height += cache.heights[line]; + } + while (cache.prefixLines < cache.heights.length && cache.heights[cache.prefixLines] >= 0) { + cache.prefixHeight += cache.heights[cache.prefixLines++]; + cache.cumulativeHeights[cache.prefixLines] = cache.prefixHeight; + } + if (populated) { + int widgetHeight = textWidget.getLinePixel(toLine) - textWidget.getLinePixel(fromLine); + if (height != widgetHeight) { + cache.bypass(fromLine, toLine, height); + } + } + if (cache.matches(textWidget)) { + if (cache.usable) { + return height; + } + return textWidget.getLinePixel(toLine) - textWidget.getLinePixel(fromLine); + } + } + lineHeightsByViewer.remove(tp); + return textWidget.getLinePixel(toLine) - textWidget.getLinePixel(fromLine); + } + + private boolean canCacheLineHeights(StyledText textWidget) { + return !textWidget.getWordWrap() + && !textWidget.isListening(ST.LineGetStyle); + } - int height = 0; - for (int i = fromLine; i < toLine; i++) { - Integer heightAtLine = lineHeights.get(i); - if (heightAtLine == null) { - int lineOffset = w.getOffsetAtLine(i); - heightAtLine = w.getLineHeight(lineOffset) + lineSpacing + w.getLineVerticalIndent(i); - lineHeights.set(i, heightAtLine); + private void validateLineHeightCache(MergeSourceViewer viewer) { + LineHeightCache cache = lineHeightsByViewer.get(viewer); + if (cache == null) { + return; + } + StyledText textWidget = viewer.getSourceViewer().getTextWidget(); + if (!canCacheLineHeights(textWidget)) { + lineHeightsByViewer.remove(viewer); + return; + } + int widgetPrefixHeight = cache.prefixLines == 0 ? 0 + : textWidget.getLinePixel(cache.prefixLines) - textWidget.getLinePixel(0); + if (!cache.matches(textWidget)) { + lineHeightsByViewer.remove(viewer); + return; + } + for (int line = cache.populatedLines.nextSetBit(0); line >= 0; + line = cache.populatedLines.nextSetBit(line + 1)) { + if (cache.indents[line] != textWidget.getLineVerticalIndent(line)) { + cache.invalidateFrom(line); + widgetPrefixHeight = cache.prefixLines == 0 ? 0 + : textWidget.getLinePixel(cache.prefixLines) - textWidget.getLinePixel(0); + break; } - height += heightAtLine; } - return height; + if (!cache.usable) { + int widgetHeight = textWidget.getLinePixel(cache.checkpointTo) + - textWidget.getLinePixel(cache.checkpointFrom); + cache.usable = cache.checkpointHeight == widgetHeight; + } + if (cache.usable && cache.prefixHeight != widgetPrefixHeight) { + invalidateLineHeightCache(viewer, cache, cache.prefixLines); + } } - private void resetCachedLineHeights(MergeSourceViewer mergeViewer) { - StyledText styledText = mergeViewer.getSourceViewer().getTextWidget(); - List lineHeightsList = lineHeightsByViewer.get(mergeViewer); - if (lineHeightsList != null) { - lineHeightsList.clear(); - lineHeightsList.addAll(Collections.nCopies(styledText.getLineCount(), null)); + private void invalidateLineHeightCache(MergeSourceViewer viewer, LineHeightCache cache, int toLine) { + StyledText textWidget = viewer.getSourceViewer().getTextWidget(); + int endLine = Math.min(toLine, Math.min(cache.heights.length, textWidget.getLineCount())); + for (int line = 0; line < endLine; line++) { + if (cache.heights[line] < 0) { + continue; + } + int lineHeight = textWidget.getLineHeight(textWidget.getOffsetAtLine(line)) + + cache.spacing + textWidget.getLineVerticalIndent(line); + if (cache.heights[line] != lineHeight) { + cache.invalidateFrom(line); + return; + } } + cache.bypass(0, cache.prefixLines, cache.prefixHeight); } private void invalidateLines() { @@ -4632,6 +4750,8 @@ private void paintCenter(Canvas canvas, GC g) { // simply ignore it in this case. return; } + validateLineHeightCache(fLeft); + validateLineHeightCache(fRight); Display display= canvas.getDisplay(); @@ -4660,9 +4780,6 @@ private void paintCenter(Canvas canvas, GC g) { } if (fMerger.hasChanges()) { - int lshift = calculateShift(fLeft); - int rshift = calculateShift(fRight); - Point region= new Point(0, 0); boolean allOutgoing = allOutgoing(); @@ -4675,13 +4792,13 @@ private void paintCenter(Canvas canvas, GC g) { fLeft.getLineRange(diff.getPosition(LEFT_CONTRIBUTOR), region); region.x -= fLeft.getDocumentRegionOffset(); int diffLines = region.y; - int ly = getHeightBetweenLines(fLeft, 0, region.x) + lshift; + int ly = getLineY(fLeft, region.x); int lh = getHeightBetweenLines(fLeft, region.x, region.x + region.y); fRight.getLineRange(diff.getPosition(RIGHT_CONTRIBUTOR), region); region.x -= fRight.getDocumentRegionOffset(); diffLines = Math.max(diffLines, region.y); - int ry = getHeightBetweenLines(fRight, 0, region.x) + rshift; + int ry = getLineY(fRight, region.x); int rh = getHeightBetweenLines(fRight, region.x, region.x + region.y); if (Math.max(ly+lh, ry+rh) < 0) { @@ -4770,11 +4887,13 @@ private double[] buildBaseCenterCurve(int width) { return curve; } - private int calculateShift(MergeSourceViewer tp) { - return tp.getSourceViewer().getTopInset() - tp.getSourceViewer().getTextWidget().getTopPixel(); + int getLineY(MergeSourceViewer tp, int line) { + StyledText textWidget = tp.getSourceViewer().getTextWidget(); + return textWidget.getLinePixel(line) - textWidget.getTopMargin() + tp.getSourceViewer().getTopInset(); } private void paintSides(GC g, MergeSourceViewer tp, Canvas canvas, boolean right) { + validateLineHeightCache(tp); Display display= canvas.getDisplay(); @@ -4802,8 +4921,6 @@ private void paintSides(GC g, MergeSourceViewer tp, Canvas canvas, boolean right if (fMerger.hasChanges()) { boolean allOutgoing = allOutgoing(); - int shift = calculateShift(tp) + (2 - LW); - Point region= new Point(0, 0); char leg = getLeg(tp); for (Iterator iterator = fMerger.changesIterator(); iterator.hasNext();) { @@ -4814,7 +4931,7 @@ private void paintSides(GC g, MergeSourceViewer tp, Canvas canvas, boolean right tp.getLineRange(diff.getPosition(leg), region); region.x -= tp.getDocumentRegionOffset(); - int y = getHeightBetweenLines(tp, 0, region.x) + shift; + int y = getLineY(tp, region.x) + (2 - LW); int h = getHeightBetweenLines(tp, region.x, region.x + region.y); if (y+h < 0) { @@ -4852,7 +4969,8 @@ private boolean allOutgoing() { return allOutgoing; } - private void paint(PaintEvent event, MergeSourceViewer tp) { + void paint(PaintEvent event, MergeSourceViewer tp) { + validateLineHeightCache(tp); if (! fHighlightRanges) { return; @@ -4865,11 +4983,8 @@ private void paint(PaintEvent event, MergeSourceViewer tp) { GC g= event.gc; int w= canvas.getSize().x; - int shift = calculateShift(tp) + (2 - LW); int maxh= event.y+event.height; // visibleHeight - shift += fTopInset; - Point range= new Point(0, 0); char leg = getLeg(tp); @@ -4882,7 +4997,7 @@ private void paint(PaintEvent event, MergeSourceViewer tp) { tp.getLineRange(diff.getPosition(leg), range); range.x -= tp.getDocumentRegionOffset(); - int y = getHeightBetweenLines(tp, 0, range.x) + shift; + int y = getLineY(tp, range.x) + (2 - LW) + fTopInset; int h = getHeightBetweenLines(tp, range.x, range.x + range.y); if (y+h < event.y) { @@ -5696,6 +5811,21 @@ private void handleException(Throwable throwable) { public T getAdapter(Class adapter) { if (adapter == IMergeViewerTestAdapter.class) { return (T) new IMergeViewerTestAdapter() { + @Override + public int getLineY(MergeSourceViewer sourceViewer, int line) { + return TextMergeViewer.this.getLineY(sourceViewer, line); + } + + @Override + public int getHeightBetweenLines(MergeSourceViewer sourceViewer, int fromLine, int toLine) { + return TextMergeViewer.this.getHeightBetweenLines(sourceViewer, fromLine, toLine); + } + + @Override + public void paint(PaintEvent event, MergeSourceViewer sourceViewer) { + TextMergeViewer.this.paint(event, sourceViewer); + } + @Override public IDocument getDocument(char leg) { switch (leg) { diff --git a/team/bundles/org.eclipse.compare/compare/org/eclipse/compare/internal/IMergeViewerTestAdapter.java b/team/bundles/org.eclipse.compare/compare/org/eclipse/compare/internal/IMergeViewerTestAdapter.java index 0ec8091cc57..2c30694089f 100644 --- a/team/bundles/org.eclipse.compare/compare/org/eclipse/compare/internal/IMergeViewerTestAdapter.java +++ b/team/bundles/org.eclipse.compare/compare/org/eclipse/compare/internal/IMergeViewerTestAdapter.java @@ -14,6 +14,7 @@ package org.eclipse.compare.internal; import org.eclipse.jface.text.IDocument; +import org.eclipse.swt.events.PaintEvent; /** * An interface that provides access to the internals of a merge viewer for the purposes of testing. @@ -34,4 +35,40 @@ public interface IMergeViewerTestAdapter { * @return the number of changes */ public int getChangesCount(); + + /** + * Returns the vertical position used to draw comparison highlights for a line. + * + * @param viewer the source viewer + * @param line the zero-based line index + * @return the vertical position in pixels + * @throws UnsupportedOperationException if this adapter does not support geometry access + */ + default int getLineY(MergeSourceViewer viewer, int line) { + throw new UnsupportedOperationException(); + } + + /** + * Returns the height of the given line range. + * + * @param viewer the source viewer + * @param fromLine the zero-based start line, inclusive + * @param toLine the zero-based end line, exclusive + * @return the height in pixels + * @throws UnsupportedOperationException if this adapter does not support geometry access + */ + default int getHeightBetweenLines(MergeSourceViewer viewer, int fromLine, int toLine) { + throw new UnsupportedOperationException(); + } + + /** + * Paints comparison highlights for the given source viewer. + * + * @param event the paint event containing the graphics context + * @param viewer the source viewer + * @throws UnsupportedOperationException if this adapter does not support painting access + */ + default void paint(PaintEvent event, MergeSourceViewer viewer) { + throw new UnsupportedOperationException(); + } } diff --git a/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/AllCompareTests.java b/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/AllCompareTests.java index 9fed2f0de76..c495125513d 100644 --- a/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/AllCompareTests.java +++ b/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/AllCompareTests.java @@ -23,6 +23,8 @@ @Suite @SelectClasses({ TextMergeViewerTest.class, + TextMergeViewerGeometryTest.class, + TextMergeViewerScrollRegressionTest.class, LineReaderTest.class, StreamMergerTest.class, DocLineComparatorTest.class, diff --git a/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerGeometryTest.java b/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerGeometryTest.java new file mode 100644 index 00000000000..60cbf626dc9 --- /dev/null +++ b/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerGeometryTest.java @@ -0,0 +1,420 @@ +/******************************************************************************* + * Copyright (c) 2026 Eclipse contributors and others. + * + * This program and the accompanying materials + * are made available under the terms of the Eclipse Public License 2.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Eclipse contributors - initial API and implementation + *******************************************************************************/ +package org.eclipse.compare.tests; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertNotSame; +import static org.junit.jupiter.api.Assertions.assertNotNull; +import static org.junit.jupiter.api.Assertions.assertNull; +import static org.junit.jupiter.api.Assertions.assertSame; +import static org.junit.jupiter.api.Assertions.assertTrue; + +import java.util.Map; + +import org.eclipse.compare.CompareConfiguration; +import org.eclipse.compare.contentmergeviewer.TextMergeViewer; +import org.eclipse.compare.internal.MergeSourceViewer; +import org.eclipse.compare.internal.IMergeViewerTestAdapter; +import org.eclipse.jface.text.Document; +import org.eclipse.jface.text.TextPresentation; +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.StyledText; +import org.eclipse.swt.custom.StyleRange; +import org.eclipse.swt.events.PaintEvent; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.graphics.GlyphMetrics; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Shell; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class TextMergeViewerGeometryTest { + private Shell shell; + private TextMergeViewer viewer; + private MergeSourceViewer sourceViewer; + private StyledText textWidget; + + @BeforeEach + public void setUp() throws Exception { + shell = new Shell(Display.getDefault()); + shell.setLayout(new FillLayout()); + shell.setSize(800, 400); + viewer = new TextMergeViewer(shell, SWT.NONE, new CompareConfiguration()); + sourceViewer = (MergeSourceViewer) ReflectionUtils.getField(viewer, "fLeft", true); + sourceViewer.getSourceViewer().setDocument(new Document("unchanged context\n".repeat(100))); + textWidget = sourceViewer.getSourceViewer().getTextWidget(); + shell.open(); + } + + @AfterEach + public void tearDown() { + shell.dispose(); + } + + @Test + public void testLineHeightChangesWithoutDocumentChanges() throws Exception { + textWidget.setLineSpacing(50); + int initialHeight = heightBetweenLines(0, 80); + Object initialCache = caches().get(sourceViewer); + Font originalFont = textWidget.getFont(); + FontData[] fontData = originalFont.getFontData(); + for (FontData data : fontData) { + data.setHeight(data.getHeight() + 8); + } + Font largerFont = new Font(textWidget.getDisplay(), fontData); + try { + textWidget.setFont(largerFont); + textWidget.setTopIndex(70); + int expectedHeight = textWidget.getLinePixel(80) - textWidget.getLinePixel(0); + assertTrue(expectedHeight > initialHeight); + assertEquals(expectedHeight, heightBetweenLines(0, 80)); + assertNotSame(initialCache, caches().get(sourceViewer)); + assertEquals(textWidget.getLinePixel(81) - textWidget.getLinePixel(80), heightBetweenLines(80, 81)); + } finally { + textWidget.setFont(originalFont); + largerFont.dispose(); + } + } + + @Test + public void testLineSpacingAndIndentChangesWhileScrolled() throws Exception { + textWidget.setLineSpacing(50); + heightBetweenLines(0, 80); + textWidget.setLineSpacing(0); + textWidget.setLineSpacingProvider(line -> line % 3 == 0 ? 7 : 0); + textWidget.setLineVerticalIndent(75, 13); + textWidget.setTopIndex(70); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertEquals(textWidget.getLinePixel(76) - textWidget.getLinePixel(75), heightBetweenLines(75, 76)); + assertEquals(0, heightBetweenLines(80, 80)); + assertEquals(textWidget.getLinePixel(textWidget.getLineCount()) - textWidget.getLinePixel(99), + heightBetweenLines(99, textWidget.getLineCount())); + assertEquals(false, ReflectionUtils.getField(caches().get(sourceViewer), "usable")); + } + + @Test + public void testOutOfDocumentHeightKeepsExistingEstimate() throws Exception { + textWidget.setLineVerticalIndent(0, 13); + for (int spacing : new int[] { 0, 50 }) { + textWidget.setLineSpacing(spacing); + int lastLine = textWidget.getLineCount(); + int expectedHeight = 3 * (textWidget.getLineHeight() + textWidget.getLineVerticalIndent(0)) + spacing; + assertEquals(expectedHeight, heightBetweenLines(lastLine, lastLine + 3)); + assertEquals(0, heightBetweenLines(lastLine + 3, lastLine + 3)); + } + } + + @Test + public void testCacheReusedWithUnchangedMetrics() throws Exception { + textWidget.setLineSpacing(50); + int initialHeight = heightBetweenLines(0, 80); + Object initialCache = caches().get(sourceViewer); + textWidget.setTopIndex(70); + assertEquals(initialHeight, heightBetweenLines(0, 80)); + assertSame(initialCache, caches().get(sourceViewer)); + } + + @Test + public void testZeroSpacingWithVerticalIndentsKeepsCache() throws Exception { + textWidget.setLineSpacing(0); + textWidget.setLineVerticalIndent(10, 13); + int initialHeight = heightBetweenLines(0, 80); + Object initialCache = caches().get(sourceViewer); + assertNotNull(initialCache, "Vertical indents need caching even with zero line spacing"); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), initialHeight); + textWidget.setTopIndex(70); + assertEquals(initialHeight, heightBetweenLines(0, 80)); + assertSame(initialCache, caches().get(sourceViewer)); + textWidget.setLineVerticalIndent(10, 0); + textWidget.setLineVerticalIndent(75, 13); + assertEquals(initialHeight, heightBetweenLines(0, 80)); + assertEquals(textWidget.getLinePixel(20) - textWidget.getLinePixel(0), heightBetweenLines(0, 20)); + assertSame(initialCache, caches().get(sourceViewer)); + } + + @Test + public void testCachedIndentAndSpacingChanges() throws Exception { + textWidget.setLineSpacing(50); + int initialHeight = heightBetweenLines(0, 80); + textWidget.setLineVerticalIndent(75, 13); + assertEquals(initialHeight + 13, heightBetweenLines(0, 80)); + textWidget.setLineSpacing(60); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + } + + @Test + public void testCacheInvalidatedByDocumentChanges() throws Exception { + textWidget.setLineSpacing(50); + heightBetweenLines(0, 80); + Object initialCache = caches().get(sourceViewer); + sourceViewer.getSourceViewer().getDocument().replace(0, 0, "inserted line\n"); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertNotSame(initialCache, caches().get(sourceViewer)); + } + + @Test + public void testCacheInvalidatedBySameLineCountDocumentChanges() throws Exception { + textWidget.setLineSpacing(50); + heightBetweenLines(0, 80); + Object initialCache = caches().get(sourceViewer); + int initialLineCount = textWidget.getLineCount(); + sourceViewer.getSourceViewer().getDocument().replace(textWidget.getOffsetAtLine(10), 9, "replacement"); + assertEquals(initialLineCount, textWidget.getLineCount()); + assertNull(caches().get(sourceViewer)); + assertEquals(textWidget.getLinePixel(20) - textWidget.getLinePixel(0), heightBetweenLines(0, 20)); + assertNotSame(initialCache, caches().get(sourceViewer)); + } + + @Test + public void testWordWrapBypassesCache() throws Exception { + textWidget.setLineSpacing(50); + heightBetweenLines(0, 80); + textWidget.setWordWrap(true); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertNull(caches().get(sourceViewer)); + } + + @Test + public void testCacheInvalidatedByPresentationChanges() throws Exception { + textWidget.setLineSpacing(50); + heightBetweenLines(0, 80); + Object initialCache = caches().get(sourceViewer); + TextPresentation presentation = new TextPresentation(); + presentation.addStyleRange(new StyleRange(0, 4, null, null, SWT.BOLD)); + sourceViewer.getSourceViewer().changeTextPresentation(presentation, true); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertNotSame(initialCache, caches().get(sourceViewer)); + } + + @Test + public void testCheckpointOnlyUsesPopulatedPrefix() throws Exception { + textWidget.setLineSpacing(50); + int initialHeight = heightBetweenLines(0, 20); + Object initialCache = caches().get(sourceViewer); + assertEquals(20, ReflectionUtils.getField(initialCache, "prefixLines")); + int[] heights = (int[]) ReflectionUtils.getField(initialCache, "heights"); + assertEquals(-1, heights[20]); + textWidget.setLineVerticalIndent(10, 13); + assertEquals(initialHeight + 13, heightBetweenLines(0, 20)); + Object refreshedCache = caches().get(sourceViewer); + assertSame(initialCache, refreshedCache); + assertEquals(20, ReflectionUtils.getField(refreshedCache, "prefixLines")); + assertEquals(-1, ((int[]) ReflectionUtils.getField(refreshedCache, "heights"))[20]); + } + + @Test + public void testStaleCachePreservesPrefixAndDropsPopulatedSuffix() throws Exception { + textWidget.setLineSpacing(50); + heightBetweenLines(0, 20); + heightBetweenLines(70, 80); + Object initialCache = caches().get(sourceViewer); + int[] heights = (int[]) ReflectionUtils.getField(initialCache, "heights"); + int preservedHeight = heightBetweenLines(0, 10); + assertTrue(heights[70] > 0); + textWidget.setLineVerticalIndent(10, 13); + assertEquals(preservedHeight, heightBetweenLines(0, 10)); + assertSame(initialCache, caches().get(sourceViewer)); + assertEquals(10, ReflectionUtils.getField(initialCache, "prefixLines")); + assertEquals(preservedHeight, ReflectionUtils.getField(initialCache, "prefixHeight")); + for (int line = 0; line < heights.length; line++) { + if (line < 10) { + assertTrue(heights[line] > 0); + } else { + assertEquals(-1, heights[line]); + } + } + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + } + + @Test + public void testStaleCacheAtFirstLineDropsAllEntries() throws Exception { + textWidget.setLineSpacing(50); + int initialHeight = heightBetweenLines(0, 20); + Object initialCache = caches().get(sourceViewer); + textWidget.setLineVerticalIndent(0, 13); + assertEquals(initialHeight + 13, heightBetweenLines(0, 20)); + assertSame(initialCache, caches().get(sourceViewer)); + assertEquals(textWidget.getLinePixel(20) - textWidget.getLinePixel(0), heightBetweenLines(0, 20)); + } + + @Test + public void testBalancedIndentRelocationValidatesConsumedRange() throws Exception { + textWidget.setLineSpacing(50); + textWidget.setLineVerticalIndent(10, 13); + int initialHeight = heightBetweenLines(0, 80); + int initialIntermediateHeight = heightBetweenLines(0, 20); + Object initialCache = caches().get(sourceViewer); + int[] heights = (int[]) ReflectionUtils.getField(initialCache, "heights"); + int preservedHeight = heightBetweenLines(0, 10); + textWidget.setLineVerticalIndent(10, 0); + textWidget.setLineVerticalIndent(75, 13); + repaint(); + assertEquals(initialHeight, textWidget.getLinePixel(80) - textWidget.getLinePixel(0)); + assertSame(initialCache, caches().get(sourceViewer)); + assertEquals(10, ReflectionUtils.getField(initialCache, "prefixLines")); + assertEquals(preservedHeight, ReflectionUtils.getField(initialCache, "prefixHeight")); + for (int line = 0; line < heights.length; line++) { + if (line < 10) { + assertTrue(heights[line] > 0); + } else { + assertEquals(-1, heights[line]); + } + } + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertEquals(initialIntermediateHeight - 13, heightBetweenLines(0, 20)); + } + + @Test + public void testBalancedIndentRelocationBeyondCacheGap() throws Exception { + textWidget.setLineSpacing(50); + textWidget.setLineVerticalIndent(75, 13); + int preservedHeight = heightBetweenLines(0, 20); + int initialHeight = heightBetweenLines(70, 80); + int initialIntermediateHeight = heightBetweenLines(70, 76); + Object initialCache = caches().get(sourceViewer); + int[] heights = (int[]) ReflectionUtils.getField(initialCache, "heights"); + textWidget.setLineVerticalIndent(75, 0); + textWidget.setLineVerticalIndent(78, 13); + repaint(); + assertEquals(initialHeight, textWidget.getLinePixel(80) - textWidget.getLinePixel(70)); + assertSame(initialCache, caches().get(sourceViewer)); + assertEquals(20, ReflectionUtils.getField(initialCache, "prefixLines")); + assertEquals(preservedHeight, ReflectionUtils.getField(initialCache, "prefixHeight")); + for (int line = 0; line < heights.length; line++) { + if (line < 20 || line >= 70 && line < 75) { + assertTrue(heights[line] > 0); + } else { + assertEquals(-1, heights[line]); + } + } + assertEquals(initialIntermediateHeight - 13, heightBetweenLines(70, 76)); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(70), heightBetweenLines(70, 80)); + } + + @Test + public void testIndividualStyleHeightChangePreservesPrefix() throws Exception { + textWidget.setLineSpacing(50); + int initialHeight = heightBetweenLines(0, 80); + Object initialCache = caches().get(sourceViewer); + int preservedHeight = heightBetweenLines(0, 75); + StyleRange style = new StyleRange(textWidget.getOffsetAtLine(75), 1, null, null); + style.metrics = new GlyphMetrics(textWidget.getLineHeight() + 13, 0, 8); + textWidget.setStyleRange(style); + repaint(); + assertSame(initialCache, caches().get(sourceViewer)); + assertEquals(75, ReflectionUtils.getField(initialCache, "prefixLines")); + assertEquals(preservedHeight, ReflectionUtils.getField(initialCache, "prefixHeight")); + assertTrue(heightBetweenLines(0, 80) > initialHeight); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + } + + @Test + public void testBalancedVariableHeightStylesInvalidateCache() throws Exception { + textWidget.setLineSpacing(50); + heightBetweenLines(0, 80); + int unstyledIntermediateHeight = heightBetweenLines(0, 20); + Object unstyledCache = caches().get(sourceViewer); + StyleRange style = new StyleRange(textWidget.getOffsetAtLine(10), 1, null, null); + style.metrics = new GlyphMetrics(textWidget.getLineHeight() + 13, 0, 8); + TextPresentation presentation = new TextPresentation(); + presentation.setDefaultStyleRange(new StyleRange(0, textWidget.getCharCount(), null, null)); + presentation.addStyleRange(style); + sourceViewer.getSourceViewer().changeTextPresentation(presentation, true); + int initialHeight = heightBetweenLines(0, 80); + int initialIntermediateHeight = heightBetweenLines(0, 20); + assertTrue(initialIntermediateHeight > unstyledIntermediateHeight); + assertNotSame(unstyledCache, caches().get(sourceViewer)); + Object styledCache = caches().get(sourceViewer); + style.start = textWidget.getOffsetAtLine(75); + presentation = new TextPresentation(); + presentation.setDefaultStyleRange(new StyleRange(0, textWidget.getCharCount(), null, null)); + presentation.addStyleRange(style); + sourceViewer.getSourceViewer().changeTextPresentation(presentation, true); + assertEquals(initialHeight, heightBetweenLines(0, 80)); + assertEquals(unstyledIntermediateHeight, heightBetweenLines(0, 20)); + assertNotSame(styledCache, caches().get(sourceViewer)); + } + + @Test + public void testDynamicLineStylesBypassCache() throws Exception { + textWidget.setLineSpacing(50); + heightBetweenLines(0, 80); + textWidget.addLineStyleListener(event -> { + StyleRange style = new StyleRange(event.lineOffset, 1, null, null); + style.metrics = new GlyphMetrics(textWidget.getLineHeight() + 13, 0, 8); + event.styles = new StyleRange[] { style }; + }); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertNull(caches().get(sourceViewer)); + } + + @Test + public void testBalancedProviderSpacingKeepsLineCoordinatesAligned() throws Exception { + textWidget.setLineSpacing(50); + textWidget.setLineSpacingProvider(line -> line == 0 ? 60 : line == 1 ? 40 : 50); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertEquals(textWidget.getLinePixel(1) - textWidget.getTopMargin() + + sourceViewer.getSourceViewer().getTopInset(), viewer.getAdapter(IMergeViewerTestAdapter.class).getLineY(sourceViewer, 1)); + } + + @Test + public void testGeometryDisagreementBypassesCacheWithoutRefilling() throws Exception { + textWidget.setLineSpacing(50); + textWidget.setLineSpacingProvider(_ -> 60); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + Object initialCache = caches().get(sourceViewer); + assertEquals(false, ReflectionUtils.getField(initialCache, "usable")); + int[] heights = ((int[]) ReflectionUtils.getField(initialCache, "heights")).clone(); + for (int pass = 0; pass < 3; pass++) { + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertSame(initialCache, caches().get(sourceViewer)); + assertEquals(false, ReflectionUtils.getField(initialCache, "usable")); + assertTrue(java.util.Arrays.equals(heights, (int[]) ReflectionUtils.getField(initialCache, "heights"))); + } + textWidget.setLineVerticalIndent(50, 13); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertSame(initialCache, caches().get(sourceViewer)); + assertEquals(false, ReflectionUtils.getField(initialCache, "usable")); + textWidget.setLineSpacingProvider(null); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + assertSame(initialCache, caches().get(sourceViewer)); + assertEquals(true, ReflectionUtils.getField(initialCache, "usable")); + } + + private Map caches() throws Exception { + return (Map) ReflectionUtils.getField(viewer, "lineHeightsByViewer", true); + } + + private int heightBetweenLines(int fromLine, int toLine) throws Exception { + repaint(); + return viewer.getAdapter(IMergeViewerTestAdapter.class).getHeightBetweenLines(sourceViewer, fromLine, toLine); + } + + private void repaint() throws Exception { + GC gc = new GC(textWidget); + try { + Event event = new Event(); + event.widget = textWidget; + event.gc = gc; + viewer.getAdapter(IMergeViewerTestAdapter.class).paint(new PaintEvent(event), sourceViewer); + } finally { + gc.dispose(); + } + } +} diff --git a/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerScrollRegressionTest.java b/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerScrollRegressionTest.java new file mode 100644 index 00000000000..03c903b2f0d --- /dev/null +++ b/team/tests/org.eclipse.compare.tests/src/org/eclipse/compare/tests/TextMergeViewerScrollRegressionTest.java @@ -0,0 +1,165 @@ +/******************************************************************************* + * Copyright (c) 2026 Eclipse contributors and others. + * + * This program and the accompanying materials + * are made available under the terms of the Eclipse Public License 2.0 + * which accompanies this distribution, and is available at + * https://www.eclipse.org/legal/epl-2.0/ + * + * SPDX-License-Identifier: EPL-2.0 + * + * Contributors: + * Eclipse contributors - initial API and implementation + *******************************************************************************/ +package org.eclipse.compare.tests; + +import static org.junit.jupiter.api.Assertions.assertEquals; +import static org.junit.jupiter.api.Assertions.assertTrue; + + +import org.eclipse.compare.CompareConfiguration; +import org.eclipse.compare.contentmergeviewer.TextMergeViewer; +import org.eclipse.compare.internal.MergeSourceViewer; +import org.eclipse.compare.internal.IMergeViewerTestAdapter; +import org.eclipse.jface.text.Document; +import org.eclipse.swt.SWT; +import org.eclipse.swt.custom.StyledText; +import org.eclipse.swt.events.PaintEvent; +import org.eclipse.swt.graphics.Font; +import org.eclipse.swt.graphics.FontData; +import org.eclipse.swt.graphics.GC; +import org.eclipse.swt.layout.FillLayout; +import org.eclipse.swt.widgets.Display; +import org.eclipse.swt.widgets.Event; +import org.eclipse.swt.widgets.Shell; +import org.junit.jupiter.api.AfterEach; +import org.junit.jupiter.api.BeforeEach; +import org.junit.jupiter.api.Test; + +public class TextMergeViewerScrollRegressionTest { + private Shell shell; + private TextMergeViewer viewer; + private MergeSourceViewer sourceViewer; + private StyledText textWidget; + + @BeforeEach + public void setUp() throws Exception { + shell = new Shell(Display.getDefault()); + shell.setLayout(new FillLayout()); + shell.setSize(800, 400); + viewer = new TextMergeViewer(shell, SWT.NONE, new CompareConfiguration()); + sourceViewer = (MergeSourceViewer) ReflectionUtils.getField(viewer, "fLeft", true); + sourceViewer.getSourceViewer().setDocument(new Document("unchanged context\n".repeat(100))); + textWidget = sourceViewer.getSourceViewer().getTextWidget(); + textWidget.setLineSpacing(50); + shell.open(); + } + + @AfterEach + public void tearDown() { + shell.dispose(); + } + + @Test + public void testRepaintAfterFontHeightChangesWhileScrolled() throws Exception { + int initialHeight = heightBetweenLines(0, 80); + Font originalFont = textWidget.getFont(); + FontData[] fontData = originalFont.getFontData(); + for (FontData data : fontData) { + data.setHeight(data.getHeight() + 8); + } + Font largerFont = new Font(textWidget.getDisplay(), fontData); + try { + textWidget.setFont(largerFont); + textWidget.setTopIndex(70); + repaint(); + int expectedHeight = textWidget.getLinePixel(80) - textWidget.getLinePixel(0); + assertTrue(expectedHeight > initialHeight); + assertEquals(expectedHeight, heightBetweenLines(0, 80)); + } finally { + textWidget.setFont(originalFont); + largerFont.dispose(); + } + } + + @Test + public void testRepaintDetectsStalePrefixWithUnchangedBaseMetrics() throws Exception { + int initialHeight = heightBetweenLines(0, 80); + int baseHeight = textWidget.getLineHeight(); + textWidget.setLineVerticalIndent(75, 13); + textWidget.setTopIndex(70); + assertEquals(baseHeight, textWidget.getLineHeight()); + repaint(); + assertEquals(initialHeight + 13, heightBetweenLines(0, 80)); + assertEquals(textWidget.getLinePixel(80) - textWidget.getLinePixel(0), heightBetweenLines(0, 80)); + } + + @Test + public void testBalancedIndentRelocationUpdatesIntermediateLineY() throws Exception { + textWidget.setLineVerticalIndent(10, 13); + int initialHeight = heightBetweenLines(0, 80); + int initialLineY = lineY(20); + textWidget.setLineVerticalIndent(10, 0); + textWidget.setLineVerticalIndent(75, 13); + repaint(); + assertEquals(initialHeight, heightBetweenLines(0, 80)); + assertEquals(initialLineY - 13, lineY(20)); + assertLineYMatchesWidget(20); + assertEquals(textWidget.getLinePixel(20) - textWidget.getLinePixel(0), heightBetweenLines(0, 20)); + } + + @Test + public void testScrolledLineYWithPopulatedCacheAndWithoutCaching() throws Exception { + for (int spacing : new int[] { 50, 0 }) { + sourceViewer.getSourceViewer().setDocument(new Document("unchanged context\n".repeat(100))); + textWidget.setLineSpacing(spacing); + textWidget.setTopMargin(19); + textWidget.setLineVerticalIndent(10, 13); + heightBetweenLines(0, 80); + textWidget.setLineVerticalIndent(10, 0); + textWidget.setLineVerticalIndent(75, 13); + textWidget.setTopIndex(70); + repaint(); + for (int line : new int[] { 0, 20, 75, 80, 100 }) { + assertLineYMatchesWidget(line); + } + } + } + + @Test + public void testScrolledLineYBeforeCachePopulation() throws Exception { + textWidget.setTopMargin(19); + textWidget.setLineVerticalIndent(10, 13); + textWidget.setLineVerticalIndent(75, 13); + textWidget.setTopIndex(70); + for (int line : new int[] { 20, 75, 80, 100 }) { + assertLineYMatchesWidget(line); + } + } + + private int lineY(int line) throws Exception { + return viewer.getAdapter(IMergeViewerTestAdapter.class).getLineY(sourceViewer, line); + } + + private void assertLineYMatchesWidget(int line) throws Exception { + int actualY = lineY(line); + assertEquals(textWidget.getLinePixel(line) - textWidget.getTopMargin() + + sourceViewer.getSourceViewer().getTopInset(), actualY); + } + + private int heightBetweenLines(int fromLine, int toLine) throws Exception { + return viewer.getAdapter(IMergeViewerTestAdapter.class).getHeightBetweenLines(sourceViewer, fromLine, toLine); + } + + private void repaint() throws Exception { + GC gc = new GC(textWidget); + try { + Event event = new Event(); + event.widget = textWidget; + event.gc = gc; + viewer.getAdapter(IMergeViewerTestAdapter.class).paint(new PaintEvent(event), sourceViewer); + } finally { + gc.dispose(); + } + } +}