introduce DocumentFooterCodeMining to draw minings at the document end

Author: tobias-melcher

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

@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %pluginName
 Bundle-SymbolicName: org.eclipse.jface.text
-Bundle-Version: 3.27.100.qualifier
+Bundle-Version: 3.28.0.qualifier
 Bundle-Vendor: %providerName
 Bundle-Localization: plugin
 Export-Package: 

bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningDocumentFooterAnnotation.java

@@ -0,0 +1,153 @@
+/*******************************************************************************
+* Copyright (c) 2025 SAP SE
+*
+* 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
+******************************************************************************/
+package org.eclipse.jface.internal.text.codemining;
+
+import static org.eclipse.jface.internal.text.codemining.CodeMiningLineHeaderAnnotation.disposeMinings;
+import static org.eclipse.jface.internal.text.codemining.CodeMiningLineHeaderAnnotation.getMultilineHeight;
+import static org.eclipse.jface.internal.text.codemining.CodeMiningLineHeaderAnnotation.hasAtLeastOneResolvedMiningNotEmpty;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.events.MouseEvent;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Rectangle;
+
+import org.eclipse.core.runtime.IProgressMonitor;
+
+import org.eclipse.jface.text.Position;
+import org.eclipse.jface.text.codemining.ICodeMining;
+import org.eclipse.jface.text.source.ISourceViewer;
+import org.eclipse.jface.text.source.inlined.LineFooterAnnotation;
+
+/**
+ * Code Mining annotation at the end of the document.
+ *
+ */
+public class CodeMiningDocumentFooterAnnotation extends LineFooterAnnotation implements ICodeMiningAnnotation {
+
+	/**
+	 * List of resolved minings which contains current resolved minings and last resolved minings
+	 * and null if mining is not resolved.
+	 */
+	private ICodeMining[] fResolvedMinings;
+
+	/**
+	 * List of current resolved/unresolved minings
+	 */
+	private final List<ICodeMining> fMinings;
+
+	/**
+	 * List of bounds minings
+	 */
+	private final List<Rectangle> fBounds;
+
+	/**
+	 * The current progress monitor
+	 */
+	private IProgressMonitor fMonitor;
+
+	/**
+	 * Code mining annotation constructor.
+	 *
+	 * @param position the position
+	 * @param viewer the viewer
+	 * @param onMouseHover the consumer to be called on mouse hover. If set, the implementor needs
+	 *            to take care of setting the cursor if wanted.
+	 * @param onMouseOut the consumer to be called on mouse out. If set, the implementor needs to
+	 *            take care of resetting the cursor.
+	 * @param onMouseMove the consumer to be called on mouse move
+	 */
+	public CodeMiningDocumentFooterAnnotation(Position position, ISourceViewer viewer, Consumer<MouseEvent> onMouseHover, Consumer<MouseEvent> onMouseOut, Consumer<MouseEvent> onMouseMove) {
+		super(position, viewer, onMouseHover, onMouseOut, onMouseMove);
+		fResolvedMinings= null;
+		fMinings= new ArrayList<>();
+		fBounds= new ArrayList<>();
+	}
+
+	@Override
+	public int getHeight() {
+		return hasAtLeastOneResolvedMiningNotEmpty(fMinings, fResolvedMinings)
+				? getMultilineHeight(null, fMinings, super.getTextWidget(), super.getHeight())
+				: 0;
+	}
+
+	@Override
+	public void update(List<ICodeMining> minings, IProgressMonitor monitor) {
+		if (fResolvedMinings == null || (fResolvedMinings.length != minings.size())) {
+			// size of resolved minings are different from size of minings to update, initialize it with size of minings to update
+			fResolvedMinings= new ICodeMining[minings.size()];
+		}
+		// fill valid resolved minings with old minings.
+		int length= Math.min(fMinings.size(), minings.size());
+		for (int i= 0; i < length; i++) {
+			ICodeMining mining= fMinings.get(i);
+			if (mining.getLabel() != null) {
+				fResolvedMinings[i]= mining;
+			}
+		}
+		disposeMinings(fMinings);
+		fMonitor= monitor;
+		fMinings.addAll(minings);
+	}
+
+	@Override
+	public void markDeleted(boolean deleted) {
+		super.markDeleted(deleted);
+		if (deleted) {
+			disposeMinings(fMinings);
+			fResolvedMinings= null;
+		}
+	}
+
+	@Override
+	public void draw(GC gc, StyledText textWidget, int offset, int length, Color color, int x, int y) {
+		int singleLineHeight= super.getHeight();
+		CodeMiningLineHeaderAnnotation.draw(fMinings, fBounds, singleLineHeight, fResolvedMinings, gc, textWidget, color, x, y, new Runnable() {
+
+			@Override
+			public void run() {
+				redraw();
+			}
+		});
+	}
+
+	@Override
+	public void redraw() {
+		// redraw codemining annotation is done only if all current minings are resolved.
+		List<ICodeMining> minings= new ArrayList<>(fMinings);
+		for (ICodeMining mining : minings) {
+			if (!mining.isResolved()) {
+				// one of mining is not resolved, resolve it and then redraw the annotation.
+				mining.resolve(getViewer(), fMonitor).thenRunAsync(() -> {
+					this.redraw();
+				});
+				return;
+			}
+		}
+		// all minings are resolved, redraw the annotation
+		super.redraw();
+	}
+
+	@Override
+	public Consumer<MouseEvent> getAction(MouseEvent e) {
+		ICodeMining mining= CodeMiningManager.getValidCodeMiningAtLocation(fResolvedMinings, fBounds, e.x, e.y);
+		return mining != null ? mining.getAction() : null;
+	}
+
+	@Override
+	public boolean isInVisibleLines() {
+		return super.isInVisibleLines();
+	}
+}

bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningLineHeaderAnnotation.java

@@ -38,7 +38,6 @@
  * @since 3.13
  */
 public class CodeMiningLineHeaderAnnotation extends LineHeaderAnnotation implements ICodeMiningAnnotation {
-
 	private static final String SEPARATOR= " | "; //$NON-NLS-1$
 
 	/**
@@ -92,20 +91,19 @@ public CodeMiningLineHeaderAnnotation(Position position, ISourceViewer viewer, C
 
 	@Override
 	public int getHeight() {
-		return hasAtLeastOneResolvedMiningNotEmpty() ? getMultilineHeight(null) : 0;
+		return hasAtLeastOneResolvedMiningNotEmpty(fMinings, fResolvedMinings) ? getMultilineHeight(null, fMinings, super.getTextWidget(), super.getHeight()) : 0;
 	}
 
 	public int getHeight(GC gc) {
-		return hasAtLeastOneResolvedMiningNotEmpty() ? getMultilineHeight(gc) : 0;
+		return hasAtLeastOneResolvedMiningNotEmpty(fMinings, fResolvedMinings) ? getMultilineHeight(gc, fMinings, super.getTextWidget(), super.getHeight()) : 0;
 	}
 
-	private int getMultilineHeight(GC gc) {
+	static int getMultilineHeight(GC gc, List<ICodeMining> minings, StyledText styledText, int superHeight) {
 		int numLinesOfAllMinings= 0;
-		StyledText styledText= super.getTextWidget();
 		boolean ignoreFirstLine= false;
 		int sumLineHeight= 0;
-		for (int i= 0; i < fMinings.size(); i++) {
-			ICodeMining mining= fMinings.get(i);
+		for (int i= 0; i < minings.size(); i++) {
+			ICodeMining mining= minings.get(i);
 			String label= mining.getLabel();
 			if (label == null) {
 				continue;
@@ -117,12 +115,12 @@ private int getMultilineHeight(GC gc) {
 			}
 			numLinesOfAllMinings+= numLines;
 			if (gc != null) {
-				sumLineHeight= calculateLineHeight(gc, styledText, ignoreFirstLine, sumLineHeight, i, splitted);
+				sumLineHeight= calculateLineHeight(minings, gc, styledText, ignoreFirstLine, sumLineHeight, i, splitted);
 			}
 			ignoreFirstLine= true;
 		}
-		if (sumLineHeight == 0) {
-			return super.getHeight();
+		if (sumLineHeight == 0 && numLinesOfAllMinings == 0) {
+			return superHeight;
 		}
 		if (gc != null) {
 			return sumLineHeight;
@@ -133,14 +131,14 @@ private int getMultilineHeight(GC gc) {
 		}
 	}
 
-	private int calculateLineHeight(GC gc, StyledText styledText, boolean ignoreFirstLine, int sumLineHeight, int miningIndex, String[] splitted) {
+	private static int calculateLineHeight(List<ICodeMining> minings, GC gc, StyledText styledText, boolean ignoreFirstLine, int sumLineHeight, int miningIndex, String[] splitted) {
 		for (int j= 0; j < splitted.length; j++) {
 			String line= splitted[j];
 			if (j == 0 && ignoreFirstLine) {
 				continue;
 			}
-			if (j == splitted.length - 1 && miningIndex + 1 < fMinings.size()) { // last line, take first line from next mining
-				String nextLabel= fMinings.get(miningIndex + 1).getLabel();
+			if (j == splitted.length - 1 && miningIndex + 1 < minings.size()) { // last line, take first line from next mining
+				String nextLabel= minings.get(miningIndex + 1).getLabel();
 				if (nextLabel != null) {
 					String firstFromNext= nextLabel.split("\\r?\\n|\\r")[0]; //$NON-NLS-1$
 					line+= firstFromNext;
@@ -159,15 +157,15 @@ private int calculateLineHeight(GC gc, StyledText styledText, boolean ignoreFirs
 	 * @return <code>true</code> if the annotation has at least one resolved mining which have a
 	 *         label and <code>false</code> otherwise.
 	 */
-	private boolean hasAtLeastOneResolvedMiningNotEmpty() {
-		if (fMinings.stream().anyMatch(m -> m.getLabel() != null && !m.getLabel().isEmpty())) {
+	static boolean hasAtLeastOneResolvedMiningNotEmpty(List<ICodeMining> minings, ICodeMining[] resolvedMinings) {
+		if (minings.stream().anyMatch(m -> m.getLabel() != null && !m.getLabel().isEmpty())) {
 			return true; // will have a resolved mining.
 		}
 
-		if (fResolvedMinings == null || fResolvedMinings.length == 0) {
+		if (resolvedMinings == null || resolvedMinings.length == 0) {
 			return false;
 		}
-		return Stream.of(fResolvedMinings).anyMatch(CodeMiningManager::isValidMining);
+		return Stream.of(resolvedMinings).anyMatch(CodeMiningManager::isValidMining);
 	}
 
 	@Override
@@ -184,7 +182,7 @@ public void update(List<ICodeMining> minings, IProgressMonitor monitor) {
 				fResolvedMinings[i]= mining;
 			}
 		}
-		disposeMinings();
+		disposeMinings(fMinings);
 		fMonitor= monitor;
 		fMinings.addAll(minings);
 	}
@@ -193,38 +191,51 @@ public void update(List<ICodeMining> minings, IProgressMonitor monitor) {
 	public void markDeleted(boolean deleted) {
 		super.markDeleted(deleted);
 		if (deleted) {
-			disposeMinings();
+			disposeMinings(fMinings);
 			fResolvedMinings= null;
 		}
 	}
 
-	private void disposeMinings() {
-		fMinings.stream().forEach(ICodeMining::dispose);
-		fMinings.clear();
+	static void disposeMinings(List<ICodeMining> minings) {
+		minings.stream().forEach(ICodeMining::dispose);
+		minings.clear();
 	}
 
 	@Override
 	public void draw(GC gc, StyledText textWidget, int offset, int length, Color color, int x, int y) {
-		List<ICodeMining> minings= new ArrayList<>(fMinings);
+		int singleLineHeight= super.getHeight();
+		draw(fMinings, fBounds, singleLineHeight, fResolvedMinings, gc, textWidget, color, x, y, new Runnable() {
+
+			@Override
+			public void run() {
+				redraw();
+			}
+		});
+	}
+
+	static void draw(List<ICodeMining> pMinings, List<Rectangle> fBounds, int singleLineHeight, ICodeMining[] fResolvedMinings, GC gc, StyledText textWidget, Color color,
+			int x, int y, Runnable redrawRunnable) {
+		List<ICodeMining> minings= new ArrayList<>(pMinings);
 		int nbDraw= 0;
 		int separatorWidth= -1;
 		boolean redrawn= false;
 		fBounds.clear();
-		int singleLineHeight= super.getHeight();
 		int lineSpacing= textWidget.getLineSpacing();
 		for (int i= 0; i < minings.size(); i++) {
 			ICodeMining mining= minings.get(i);
 			// try to get the last resolved mining.
 			ICodeMining lastResolvedMining= (fResolvedMinings != null && fResolvedMinings.length > i) ? fResolvedMinings[i] : null;
 			if (mining.getLabel() != null) {
 				// mining is resolved without error, update the resolved mining list
-				fResolvedMinings[i]= mining;
+				if (fResolvedMinings != null) {
+					fResolvedMinings[i]= mining;
+				}
 			} else if (!mining.isResolved()) {
 				// the mining is not resolved, draw the last resolved mining
 				mining= lastResolvedMining;
 				if (!redrawn) {
 					// redraw the annotation when mining is resolved.
-					redraw();
+					redrawRunnable.run();
 					redrawn= true;
 				}
 			} else {

bundles/org.eclipse.jface.text/src/org/eclipse/jface/internal/text/codemining/CodeMiningManager.java

@@ -42,6 +42,7 @@
 import org.eclipse.jface.text.IDocument;
 import org.eclipse.jface.text.ITextViewer;
 import org.eclipse.jface.text.Position;
+import org.eclipse.jface.text.codemining.DocumentFooterCodeMining;
 import org.eclipse.jface.text.codemining.ICodeMining;
 import org.eclipse.jface.text.codemining.ICodeMiningProvider;
 import org.eclipse.jface.text.codemining.LineContentCodeMining;
@@ -272,9 +273,16 @@ private void renderCodeMinings(Map<Position, List<ICodeMining>> groups, ISourceV
 					mouseOut= first.getMouseOut();
 					mouseMove= first.getMouseMove();
 				}
-				ann= inLineHeader
-						? new CodeMiningLineHeaderAnnotation(pos, viewer, mouseHover, mouseOut, mouseMove)
-						: new CodeMiningLineContentAnnotation(pos, viewer, afterPosition, mouseHover, mouseOut, mouseMove);
+				if (inLineHeader) {
+					ann= new CodeMiningLineHeaderAnnotation(pos, viewer, mouseHover, mouseOut, mouseMove);
+				} else {
+					boolean inFooter= !minings.isEmpty() ? (first instanceof DocumentFooterCodeMining) : false;
+					if (inFooter) {
+						ann= new CodeMiningDocumentFooterAnnotation(pos, viewer, mouseHover, mouseOut, mouseMove);
+					} else {
+						ann= new CodeMiningLineContentAnnotation(pos, viewer, afterPosition, mouseHover, mouseOut, mouseMove);
+					}
+				}
 			} else if (ann instanceof ICodeMiningAnnotation && ((ICodeMiningAnnotation) ann).isInVisibleLines()) {
 				// annotation is in visible lines
 				annotationsToRedraw.add((ICodeMiningAnnotation) ann);

bundles/org.eclipse.jface.text/src/org/eclipse/jface/text/codemining/DocumentFooterCodeMining.java

@@ -0,0 +1,46 @@
+/*******************************************************************************
+* Copyright (c) 2025 SAP SE
+*
+* 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
+******************************************************************************/
+package org.eclipse.jface.text.codemining;
+
+import java.util.concurrent.Callable;
+import java.util.function.Consumer;
+
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.events.MouseEvent;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.GC;
+import org.eclipse.swt.graphics.Point;
+
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.Position;
+
+/**
+ * A code mining rendered at the start of the line, located at the very end of the document.
+ *
+ * @since 3.28
+ */
+public class DocumentFooterCodeMining extends AbstractCodeMining {
+
+	public DocumentFooterCodeMining(IDocument document, ICodeMiningProvider provider, Consumer<MouseEvent> action) {
+		super(new Position(document.getLength(), 0), provider, action);
+	}
+
+	@Override
+	public Point draw(GC gc, StyledText textWidget, Color color, int x, int y) {
+		return LineHeaderCodeMining.draw(getLabel(), gc, textWidget, x, y, new Callable<Point>() {
+
+			@Override
+			public Point call() throws Exception {
+				return DocumentFooterCodeMining.super.draw(gc, textWidget, color, x, y);
+			}
+		});
+	}
+}