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(); + } + } +}