hide projection annotations outside of the current visible region

Projection regions that overlap with parts of the file outside of the
current visible region cannot be collapsed hence their annotations
should not be painted.

Author: danthe1st

bundles/org.eclipse.jface.text/projection/org/eclipse/jface/text/source/projection/ProjectionAnnotation.java

@@ -73,6 +73,8 @@ public void run() {
 	/** Indicates whether this annotation should be painted as range */
 	private boolean fIsRangeIndication= false;
 
+	private boolean hidden= false;
+
 	/**
 	 * Creates a new expanded projection annotation.
 	 */
@@ -115,6 +117,9 @@ private void drawRangeIndication(GC gc, Canvas canvas, Rectangle r) {
 
 	@Override
 	public void paint(GC gc, Canvas canvas, Rectangle rectangle) {
+		if (hidden) {
+			return;
+		}
 		Image image= getImage(canvas.getDisplay());
 		if (image != null) {
 			ImageUtilities.drawImage(image, gc, canvas, rectangle, SWT.CENTER, SWT.TOP);
@@ -128,6 +133,10 @@ public void paint(GC gc, Canvas canvas, Rectangle rectangle) {
 		}
 	}
 
+	void setHidden(boolean hidden) {
+		this.hidden= hidden;
+	}
+
 	@Override
 	public int getLayer() {
 		return IAnnotationPresentation.DEFAULT_LAYER;

bundles/org.eclipse.jface.text/projection/org/eclipse/jface/text/source/projection/ProjectionViewer.java

@@ -124,6 +124,7 @@ private void processModelChanged(IAnnotationModel model, AnnotationModelEvent ev
 					fProjectionSummary.updateSummaries();
 				}
 				processCatchupRequest(event);
+				correctChangedAnnotationVisibility(event);
 
 			} else if (model == getAnnotationModel() && fProjectionSummary != null) {
 				fProjectionSummary.updateSummaries();
@@ -770,15 +771,46 @@ public void setVisibleRegion(int start, int length) {
 			// If the visible region changes, make sure collapsed regions outside of the old visible regions are expanded
 			// and collapse everything outside the new visible region
 			int end= computeEndOfVisibleRegion(start, length, document);
+			Region newVisibleRegion= new Region(start, end - start - 1);
+			expandProjectionAnnotationsBorderingRegion(newVisibleRegion);
 			expandOutsideCurrentVisibleRegion(document);
 			collapseOutsideOfNewVisibleRegion(start, end, document);
-			fConfiguredVisibleRegion= new Region(start, end - start - 1);
+			fConfiguredVisibleRegion= newVisibleRegion;
+			hideProjectionAnnotationsOutsideOfVisibleRegion();
 		} catch (BadLocationException e) {
 			ILog log= ILog.of(getClass());
 			log.log(new Status(IStatus.WARNING, getClass(), IStatus.OK, null, e));
 		}
 	}
 
+	private void expandProjectionAnnotationsBorderingRegion(Region region) throws BadLocationException {
+		for (Iterator<Annotation> it= fProjectionAnnotationModel.getAnnotationIterator(); it.hasNext();) {
+			Annotation annotation= it.next();
+			Position position= fProjectionAnnotationModel.getPosition(annotation);
+			if (bordersRegion(position, region)) {
+				fProjectionAnnotationModel.expand(annotation);
+			}
+		}
+	}
+
+	private void hideProjectionAnnotationsOutsideOfVisibleRegion() throws BadLocationException {
+		for (Iterator<Annotation> it= fProjectionAnnotationModel.getAnnotationIterator(); it.hasNext();) {
+			Annotation annotation= it.next();
+			hideProjectionAnnotationIfPartsAreOutsideOfVisibleRegion(annotation);
+		}
+	}
+
+	private void hideProjectionAnnotationIfPartsAreOutsideOfVisibleRegion(Annotation annotation) throws BadLocationException {
+		Position position= fProjectionAnnotationModel.getPosition(annotation);
+		if (annotation instanceof ProjectionAnnotation a) {
+			if (overlapsWithNonVisibleRegions(position.getOffset(), position.getLength())) {
+				a.setHidden(true);
+			} else {
+				a.setHidden(false);
+			}
+		}
+	}
+
 	private void expandOutsideCurrentVisibleRegion(IDocument document) throws BadLocationException {
 		if (fConfiguredVisibleRegion != null) {
 			expand(0, fConfiguredVisibleRegion.getOffset(), false, true);
@@ -855,6 +887,12 @@ public void resetVisibleRegion() {
 			super.resetVisibleRegion();
 		}
 		fConfiguredVisibleRegion= null;
+		for (Iterator<Annotation> it= fProjectionAnnotationModel.getAnnotationIterator(); it.hasNext();) {
+			Annotation annotation= it.next();
+			if (annotation instanceof ProjectionAnnotation a) {
+				a.setHidden(false);
+			}
+		}
 	}
 
 	@Override
@@ -1014,11 +1052,25 @@ private boolean overlapsWithNonVisibleRegions(int offset, int length) throws Bad
 			return false;
 		}
 		// ignore overlaps within the same line
-		int visibleRegionStartLineOffset= getDocument().getLineInformationOfOffset(fConfiguredVisibleRegion.getOffset()).getOffset();
-		int regionToCheckEndLineOffset= getDocument().getLineInformationOfOffset(offset + length).getOffset();
+		int visibleRegionStartLineOffset= atStartOfLine(fConfiguredVisibleRegion.getOffset());
+		int regionToCheckEndLineOffset= atStartOfLine(offset + length);
 		return offset < visibleRegionStartLineOffset || regionToCheckEndLineOffset > fConfiguredVisibleRegion.getOffset() + fConfiguredVisibleRegion.getLength();
 	}
 
+
+	private boolean bordersRegion(Position position, Region region) throws BadLocationException {
+		if (position.getOffset() > atStartOfLine(region.getOffset())
+				&& atStartOfLine(position.getOffset() + position.getLength()) < region.getOffset() + region.getLength()) {
+			return true;
+		}
+		return atStartOfLine(position.getOffset()) < region.getOffset()
+				&& position.getOffset() + position.getLength() > atStartOfLine(region.getOffset() + region.getLength());
+	}
+
+	private int atStartOfLine(int off) throws BadLocationException {
+		return getDocument().getLineInformationOfOffset(off).getOffset();
+	}
+
 	/**
 	 * Processes the request for catch up with the annotation model in the UI thread. If the current
 	 * thread is not the UI thread or there are pending catch up requests, a new request is posted.
@@ -1090,6 +1142,20 @@ protected final void postCatchupRequest(final AnnotationModelEvent event) {
 		}
 	}
 
+	private void correctChangedAnnotationVisibility(AnnotationModelEvent event) {
+		try {
+			for (Annotation annotation : event.getAddedAnnotations()) {
+				hideProjectionAnnotationIfPartsAreOutsideOfVisibleRegion(annotation);
+			}
+			for (Annotation annotation : event.getChangedAnnotations()) {
+				hideProjectionAnnotationIfPartsAreOutsideOfVisibleRegion(annotation);
+			}
+		} catch (BadLocationException e) {
+			ILog log= ILog.of(getClass());
+			log.log(new Status(IStatus.WARNING, getClass(), IStatus.OK, null, e));
+		}
+	}
+
 	/**
 	 * Tests whether the visible document's master document
 	 * is identical to this viewer's document.

tests/org.eclipse.jface.text.tests/META-INF/MANIFEST.MF

@@ -30,6 +30,7 @@ Import-Package: org.mockito,
  org.mockito.invocation,
  org.mockito.stubbing,
  org.junit.jupiter.api;version="[5.14.0,6.0.0)",
+ org.junit.jupiter.api.function;version="[5.14.0,6.0.0)",
  org.junit.jupiter.params;version="[5.14.0,6.0.0)",
  org.junit.jupiter.params.provider;version="[5.14.0,6.0.0)",
  org.junit.platform.suite.api;version="[1.14.0,2.0.0)"

tests/org.eclipse.jface.text.tests/src/org/eclipse/jface/text/tests/ProjectionViewerTest.java

@@ -11,6 +11,7 @@
 package org.eclipse.jface.text.tests;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 
 import org.junit.jupiter.api.Test;
 
@@ -19,6 +20,7 @@
 import org.eclipse.swt.dnd.TextTransfer;
 import org.eclipse.swt.layout.FillLayout;
 import org.eclipse.swt.widgets.Composite;
+import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Shell;
 
 import org.eclipse.jface.text.BadLocationException;
@@ -368,4 +370,88 @@ public void testRemoveEntireVisibleRegion() throws BadLocationException {
 			shell.dispose();
 		}
 	}
+
+	@Test
+	public void testProjectionRegionsShownOnlyInVisibleRegion() {
+		Shell shell= new Shell(Display.getCurrent());
+		shell.setLayout(new FillLayout());
+		TestProjectionViewer viewer= new TestProjectionViewer(shell, null, null, true, SWT.ALL);
+		String documentContent= """
+
+				visible_region_start
+
+				projection_start
+
+				visible_region_end
+
+				projection_end
+
+				""";
+		Document document= new Document(documentContent);
+		viewer.setDocument(document, new AnnotationModel());
+		ProjectionAnnotation annotation= addVisibleRegionAndProjection(viewer, documentContent);
+		try {
+			assertEquals("""
+					visible_region_start
+
+					projection_start
+
+					visible_region_end
+					""", viewer.getVisibleDocument().get());
+
+			annotation.paint(null, null, null); //should exit early and not throw NPE
+		} finally {
+			shell.dispose();
+		}
+	}
+
+	@Test
+	public void testProjectionRegionsShownWithinVisibleRegion() {
+		Shell shell= new Shell(Display.getCurrent());
+		shell.setLayout(new FillLayout());
+		TestProjectionViewer viewer= new TestProjectionViewer(shell, null, null, true, SWT.ALL);
+		String documentContent= """
+
+				visible_region_start
+
+				projection_start
+
+				projection_end
+
+				visible_region_end
+
+				""";
+		Document document= new Document(documentContent);
+		viewer.setDocument(document, new AnnotationModel());
+		ProjectionAnnotation annotation= addVisibleRegionAndProjection(viewer, documentContent);
+		try {
+			assertEquals("""
+					visible_region_start
+
+					projection_start
+
+					projection_end
+
+					visible_region_end
+					""", viewer.getVisibleDocument().get());
+
+			assertThrows(NullPointerException.class, () -> annotation.paint(null, null, null), "expected to run painting logic");
+		} finally {
+			shell.dispose();
+		}
+	}
+
+	private ProjectionAnnotation addVisibleRegionAndProjection(TestProjectionViewer viewer, String documentContent) {
+		int visibleRegionStart= documentContent.indexOf("visible_region_start");
+		int visibleRegionEnd= documentContent.indexOf("\n", documentContent.indexOf("visible_region_end")) + 1;
+
+		int projectionStart= documentContent.indexOf("projection_start");
+		int projectionEnd= documentContent.indexOf("\n", documentContent.indexOf("projection_end")) + 1;
+
+		viewer.setVisibleRegion(visibleRegionStart, visibleRegionEnd - visibleRegionStart);
+		viewer.enableProjection();
+		ProjectionAnnotation annotation= new ProjectionAnnotation();
+		viewer.getProjectionAnnotationModel().addAnnotation(annotation, new Position(projectionStart, projectionEnd - projectionStart));
+		return annotation;
+	}
 }