ITextViewerHandle that wraps text viewer used for presenting
+ * quicksearch matches within content of their containing document.
+ *
+ * @see ITextViewerHandle
+ * @since 1.4
+ */
+public interface ITextViewerCreator {
+
+ /**
+ * Creates a new text viewer under the given SWT parent control and returns handle for it. This method must
+ * always create new text viewer & handle when called since each opened quick search dialog will call this method
+ * passing unique parent to display the viewer in the dialog. Dialog then re-uses returned handle
+ * (viewer) when this ITextViewerCreator is again chosen to present some (possibly other) quicksearch
+ * match. If other ITextViewerCreator contributor is chosen to present a match in the same dialog,
+ * this viewer is just made not visible (by means of using {@link StackLayout} in the parent composites hierarchy).
+ *
+ * It's recommended to use {@link SourceViewerHandle} configured by {@link SourceViewerConfigurer} since they
+ * implement common aspects expected from quicksearch text viewers.
+ *
+ * @param parent the SWT parent control under which to create the viewer's SWT control
+ * @return a new text viewer handle
+ */
+ ITextViewerHandle createTextViewer(Composite parent);
+
+ /**
+ * Text viewer handle is a wrapper for a text viewer displayed in quicksearch dialog to present matches.
+ *
+ * @see ITextViewerCreator#createTextViewer(Composite)
+ */
+ public interface ITextViewerHandle {
+
+ /**
+ * Returns number of lines of text the client area of this handle's text viewer would display with its current
+ * size. Value is used to calculate regions subsequently passed to
+ * {@link #focusMatch(IRegion, IRegion, int, IRegion) focusMatch()}.
+ *
+ * @return number of visible text lines
+ * @see #focusMatch(IRegion, IRegion, int, IRegion)
+ */
+ int getVisibleLines();
+
+ /**
+ * Sets input to the text viewer of this handle. Only if different document is to be presented in this handle's
+ * viewer, this method is called with new input document. If different match in the already displayed document
+ * is to be presented, only {@link #focusMatch(IRegion, IRegion, int, IRegion) focusMatch()} is called.
+ *
+ * @param document the document to present in the viewer (content of the file)
+ * @param allMatchesStyles common text styles to apply in order to highlight all found matches in the document
+ * @param file the file contents of which is the document
+ * @see #focusMatch(IRegion, IRegion, int, IRegion)
+ */
+ void setViewerInput(IDocument document, StyleRange[] allMatchesStyles, IFile file);
+
+ /**
+ * Focuses on the specific match (selected amongst quicksearch results) within content of its containing
+ * document, which was previously set as viewer's input by call to
+ * {@link #setViewerInput(IDocument, StyleRange[], IFile) setViewerInput()}. This is expected to mean:
+ *
visibleRegion
+ * revealedRange part of the input document (vertical scrolling)
+ * matchLine
+ * matchRange is visible (horizontal scrolling)
+ * matchRange
+ *
+ * All parameters are coordinates within the input document previously set by call to
+ * {@link #setViewerInput(IDocument, StyleRange[], IFile) setViewerInput()}.
+ *
+ * @param visibleRegion bounds of the portion of input document to present in the viewer
+ * @param revealedRange bounds of the part of input document to reveal (for vertical scroll)
+ * @param matchLine line number in the input document where match is located
+ * @param matchRange bounds of the focused match in the input document (for horizontal scroll)
+ * @see #getVisibleLines()
+ * @see #setViewerInput(IDocument, StyleRange[], IFile)
+ */
+ void focusMatch(IRegion visibleRegion, IRegion revealedRange, int matchLine, IRegion matchRange);
+ }
+
+}
diff --git a/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/ReconcilingAwareSourceViewerHandle.java b/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/ReconcilingAwareSourceViewerHandle.java
new file mode 100644
index 00000000000..0e5c8751084
--- /dev/null
+++ b/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/ReconcilingAwareSourceViewerHandle.java
@@ -0,0 +1,162 @@
+package org.eclipse.text.quicksearch;
+
+import java.util.Iterator;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.ITextPresentationListener;
+import org.eclipse.jface.text.TextPresentation;
+import org.eclipse.jface.text.source.SourceViewer;
+import org.eclipse.swt.custom.StyleRange;
+import org.eclipse.swt.events.DisposeEvent;
+import org.eclipse.swt.events.DisposeListener;
+import org.eclipse.swt.widgets.Composite;
+
+/**
+ * Extension of {@link SourceViewerHandle} which by means of registering itself as a {@link ITextPresentationListener}
+ * observes styles applied to source viewer's text from presentation reconcilers and merges quick search matches
+ * highlighting styles into them. It also collects all these styles to be later able to apply them when the handle
+ * is asked to focus different match in the document. This is to overcome shortcomings of those source viewers that use
+ * multiple presentation reconcilers but trigger only some of them on when viewer's visible area is changed on match
+ * focus.
+ *
+ * @since 1.4
+ */
+public class ReconcilingAwareSourceViewerHandle
+ * If this configurer provides non-null
+ * Default implementation does nothing, clients may replace.
+ * Subclasses may extend.
+ *
+ * Highlighting the selected match line is achieved by:
+ *
+ * This class uses {@link ISourceViewerConfigurer} that does viewer creation and setup necessary for
+ * aforementioned aspects.
+ *
+ * @since 1.4
+ */
+public class SourceViewerHandle
+ * Note: Images returned from this method will be automatically disposed
+ * of when this plug-in shuts down. Callers must not dispose of these
+ * images themselves.
+ * collectStylesInSetInput and
+ * collectStylesInFocusMatch, will also collect applied styles while executing
+ * {@link #setViewerInput(IDocument, StyleRange[], IFile) setViewerInput()} and
+ * {@link #focusMatch(IRegion, IRegion, int, IRegion) focusMatch()} respectively.
+ *
+ * @param sourceViewerConfigurer the viewer configurer responsible for creation & setup of the viewer
+ * @param parent the parent SWT control for the viewer
+ * @param collectStylesInSetInput whether to collect styles also during execution of
+ * {@link #setViewerInput(IDocument, StyleRange[], IFile) setViewerInput()} method
+ * @param collectStylesInFocusMatch whether to collect styles also during execution of
+ * {@link #focusMatch(IRegion, IRegion, int, IRegion) focusMatch()}
+ */
+ public ReconcilingAwareSourceViewerHandle(ISourceViewerConfigurerpresentation
+ * considering presentation's extent. Styles either replace ({@link TextPresentation#replaceStyleRange(StyleRange)})
+ * or are merged ({@link TextPresentation#mergeStyleRange(StyleRange)}) with text presentation's styles in the
+ * particular ranges depending on mergeStyles parameter.
+ *
+ * @param mergeStyles true if the styles should be merged, false if they should replace
+ * text presentation styles in the same ranges
+ * @see #setViewerInput(IDocument, StyleRange[], IFile)
+ */
+ protected void applyMatchStyles(TextPresentation presentation, boolean mergeStyles) {
+ if (fMatchStylesPresentation == null) {
+ // should never happen
+ return;
+ }
+ var extent = presentation.getExtent();
+ int extentStart = extent.getOffset();
+ fMatchStylesPresentation.setResultWindow(extent);
+ for (Iterator
+ *
+ *
+ * Actual source viewer instance creation is delegated to provided {@link ISourceViewerCreator}.
+ * @since 1.3
+ */
+public class SourceViewerConfigurerviewerCreator as a source viewer factory and common store
+ * to get preferences from for the viewer configuration.
+ * @param viewerCreator the factory for actual source viewer
+ */
+ public SourceViewerConfigurer(ISourceViewerCreatorviewerCreator as a source viewer factory and store
+ * to get preferences from for the viewer configuration.
+ * @param viewerCreator the factory for actual source viewer
+ * @param store the preference store to use for configuration
+ */
+ public SourceViewerConfigurer(ISourceViewerCreatorbackgroundColor with color equal to finalColor.
+ * @param backgroundColor background color of the change ruler column
+ * @param finalColor final desired color of the diff annotation
+ * @return color to set to diff painter to make it to draw annotation with desired color
+ */
+ @SuppressWarnings("restriction")
+ public static RGB reverseInterpolateDiffPainterColor(Color backgroundColor, Color finalColor) {
+ RGB baseRGB= finalColor.getRGB();
+ RGB background= backgroundColor.getRGB();
+
+ boolean darkBase= isDark(baseRGB);
+ boolean darkBackground= isDark(background);
+ if (darkBase && darkBackground)
+ background= new RGB(255, 255, 255);
+ else if (!darkBase && !darkBackground)
+ background= new RGB(0, 0, 0);
+
+ // reverse interpolate
+ double scale = 0.6;
+ double scaleInv = 1.0 - scale;
+ return new RGB((int) ((baseRGB.red - scale * background.red) / scaleInv), (int) ((baseRGB.green - scale * background.green) / scaleInv), (int) ((baseRGB.blue - scale * background.blue) / scaleInv));
+ }
+
+
+ // copy-paste of org.eclipse.jface.internal.text.source.DiffPainter.isDark(RGB)
+ private static boolean isDark(RGB rgb) {
+ return greyLevel(rgb) > 128;
+ }
+
+ // copy-paste of org.eclipse.jface.internal.text.source.DiffPainter.greyLevel(RGB)
+ private static double greyLevel(RGB rgb) {
+ if (rgb.red == rgb.green && rgb.green == rgb.blue)
+ return rgb.red;
+ return (0.299 * rgb.red + 0.587 * rgb.green + 0.114 * rgb.blue + 0.5);
+ }
+
+ /**
+ * Gets color preference configured in store under key.
+ * @param store preference store
+ * @param key color preference key
+ * @return color preference
+ */
+ protected RGB getColorFromStore(IPreferenceStore store, String key) {
+ RGB rgb = null;
+ if (store.contains(key)) {
+ if (store.isDefault(key)) {
+ rgb = PreferenceConverter.getDefaultColor(store, key);
+ } else {
+ rgb = PreferenceConverter.getColor(store, key);
+ }
+ }
+ return rgb;
+ }
+
+ private void initializeFont() {
+
+ boolean isSharedFont= true;
+ Font font= null;
+ String symbolicFontName= getSymbolicFontName();
+
+ if (symbolicFontName != null)
+ font= JFaceResources.getFont(symbolicFontName);
+ else if (fPreferenceStore != null) {
+ // Backward compatibility
+ if (fPreferenceStore.contains(JFaceResources.TEXT_FONT) && !fPreferenceStore.isDefault(JFaceResources.TEXT_FONT)) {
+ FontData data= PreferenceConverter.getFontData(fPreferenceStore, JFaceResources.TEXT_FONT);
+
+ if (data != null) {
+ isSharedFont= false;
+ font= new Font(fSourceViewer.getTextWidget().getDisplay(), data);
+ }
+ }
+ }
+ if (font == null)
+ font= JFaceResources.getTextFont();
+
+ if (!font.equals(fSourceViewer.getTextWidget().getFont())) {
+ setFont(font);
+
+ disposeFont();
+ if (!isSharedFont)
+ fFont= font;
+ } else if (!isSharedFont) {
+ font.dispose();
+ }
+ }
+
+ // Sets the font for the source viewer sustaining selection and scroll position.
+ private void setFont(Font font) {
+ if (fSourceViewer.getDocument() != null) {
+
+ ISelectionProvider provider= fSourceViewer.getSelectionProvider();
+ ISelection selection= provider.getSelection();
+ int topIndex= fSourceViewer.getTopIndex();
+
+ Control parent= fSourceViewer.getControl();
+ parent.setRedraw(false);
+
+ fSourceViewer.getTextWidget().setFont(font);
+
+ fVerticalRuler.setFont(font);
+
+ provider.setSelection(selection);
+ fSourceViewer.setTopIndex(topIndex);
+
+ if (parent instanceof Composite composite) {
+ composite.layout(true);
+ }
+
+ parent.setRedraw(true);
+ } else {
+ fSourceViewer.getTextWidget().setFont(font);
+ fVerticalRuler.setFont(font);
+ }
+ }
+
+ private void disposeFont() {
+ if (fFont != null) {
+ fFont.dispose();
+ fFont= null;
+ }
+ }
+
+ /**
+ * Returns the property preference key for the viewer font.
+ * {@link #getSymbolicFontName() symbolicFontName} then this name
+ * is returned, otherwise {@link JFaceResources#TEXT_FONT} is returned.
+ * null
+ * in which case default text viewer font is used.
+ * @return custom symbolic font name or null for default font use
+ */
+ protected String getSymbolicFontName() {
+ return null;
+ }
+
+ /**
+ * Returns preference store used for source viewer configuration.
+ *
+ * @return this configurer's preference store which may be null
+ */
+ protected final IPreferenceStore getPreferenceStore() {
+ return fPreferenceStore;
+ }
+
+ /**
+ * Adds additional ruler contributions to the vertical ruler.
+ * verticalRuler and styles under passed
+ * parent.
+ * @param parent the parent SWT control for the viewer
+ * @param verticalRuler the vertical ruler to add to the created viewer
+ * @param styles the SWT styles for the viewer
+ * @return
+ */
+ T createSourceViewer(Composite parent, CompositeRuler verticalRuler, int styles);
+ }
+
+}
diff --git a/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/SourceViewerHandle.java b/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/SourceViewerHandle.java
new file mode 100644
index 00000000000..ec850e6bde4
--- /dev/null
+++ b/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/SourceViewerHandle.java
@@ -0,0 +1,346 @@
+/*******************************************************************************
+ * Copyright (c) 2025 Contributors to the Eclipse Foundation
+ *
+ * See the NOTICE file(s) distributed with this work for additional
+ * information regarding copyright ownership.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License 2.0 which is available at
+ * https://www.eclipse.org/legal/epl-2.0
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *
+ * Contributors:
+ * Jozef Tomek - initial API and implementation
+ *******************************************************************************/
+package org.eclipse.text.quicksearch;
+
+import java.util.Collections;
+import java.util.Iterator;
+
+import org.eclipse.core.resources.IFile;
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.CursorLinePainter;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.Position;
+import org.eclipse.jface.text.Region;
+import org.eclipse.jface.text.TextPresentation;
+import org.eclipse.jface.text.source.Annotation;
+import org.eclipse.jface.text.source.IAnnotationModel;
+import org.eclipse.jface.text.source.IAnnotationModelListener;
+import org.eclipse.jface.text.source.IChangeRulerColumn;
+import org.eclipse.jface.text.source.ILineDiffInfo;
+import org.eclipse.jface.text.source.ILineDiffer;
+import org.eclipse.jface.text.source.SourceViewer;
+import org.eclipse.swt.custom.LineBackgroundEvent;
+import org.eclipse.swt.custom.LineBackgroundListener;
+import org.eclipse.swt.custom.StyleRange;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.widgets.Composite;
+import org.eclipse.text.quicksearch.ITextViewerCreator.ITextViewerHandle;
+import org.eclipse.text.quicksearch.internal.ui.QuickSearchActivator;
+
+/**
+ * Implementation of {@link ITextViewerHandle} that provides common aspects expected from quicksearch text viewers:
+ *
+ *
+ *
+ *
+ * sourceViewerConfigurer to create viewer under the
+ * parent.
+ *
+ * @param sourceViewerConfigurer the viewer configurer responsible for creation & setup of the viewer
+ * @param parent the parent SWT control for the viewer
+ */
+ public SourceViewerHandle(ISourceViewerConfigurerIWorkbenchAdapter.getImageDescriptor, which it
+ * uses to create an image if it does not already have one.
+ * ITextViewerCreators from an IConfigurationElement.
+ *
+ * @see ITextViewerCreator
+ */
+public class ViewerDescriptor implements IViewerDescriptor {
+ private final static String ID_ATTRIBUTE = "id"; //$NON-NLS-1$
+ private final static String CLASS_ATTRIBUTE = "class"; //$NON-NLS-1$
+ private final static String LINKED_EDITOR_ATTRIBUTE = "linkedEditor"; //$NON-NLS-1$
+ private final static String LABEL_ATTRIBUTE = "label"; //$NON-NLS-1$
+
+ private final IConfigurationElement fConfiguration;
+ private final String fViewerId;
+ private final String fLabel;
+ private final String fLinkedEditorId;
+
+ private ITextViewerCreator fViewerCreator;
+
+ public ViewerDescriptor(IConfigurationElement config) {
+ fConfiguration = config;
+ fViewerId = config.getContributor().getName() + config.getAttribute(ID_ATTRIBUTE);
+ fLabel = fConfiguration.getAttribute(LABEL_ATTRIBUTE);
+ fLinkedEditorId = fConfiguration.getAttribute(LINKED_EDITOR_ATTRIBUTE);
+ }
+
+ @Override
+ public ITextViewerCreator getViewerCreator() {
+ if (fViewerCreator == null) {
+ try {
+ fViewerCreator = (ITextViewerCreator) fConfiguration.createExecutableExtension(CLASS_ATTRIBUTE);
+ } catch (CoreException e) {
+ QuickSearchActivator.log(e);
+ }
+ }
+ return fViewerCreator;
+ }
+
+ @Override
+ public String getLabel() {
+ return fLabel;
+ }
+
+ String getLinkedEditorId() {
+ return fLinkedEditorId;
+ }
+
+ String getViewerClass() {
+ return fConfiguration.getAttribute(CLASS_ATTRIBUTE);
+ }
+
+ @Override
+ public String toString() {
+ StringBuilder sb = new StringBuilder();
+ sb.append("ViewerDescriptor ["); //$NON-NLS-1$
+ sb.append("fViewerId="); //$NON-NLS-1$
+ sb.append(fViewerId);
+ sb.append(", "); //$NON-NLS-1$
+ if (fViewerCreator != null) {
+ sb.append("viewerCreator="); //$NON-NLS-1$
+ sb.append(fViewerCreator);
+ sb.append(", "); //$NON-NLS-1$
+ }
+ String viewerClass = getViewerClass();
+ if (viewerClass != null) {
+ sb.append("viewerClass="); //$NON-NLS-1$
+ sb.append(viewerClass);
+ sb.append(", "); //$NON-NLS-1$
+ }
+ if (fConfiguration != null) {
+ sb.append("configuration="); //$NON-NLS-1$
+ sb.append(fConfiguration);
+ }
+ sb.append("]"); //$NON-NLS-1$
+ return sb.toString();
+ }
+
+}
diff --git a/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/internal/util/DocumentFetcher.java b/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/internal/util/DocumentFetcher.java
index 10d9f649d53..b18c5736919 100644
--- a/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/internal/util/DocumentFetcher.java
+++ b/bundles/org.eclipse.text.quicksearch/src/org/eclipse/text/quicksearch/internal/util/DocumentFetcher.java
@@ -50,14 +50,18 @@
*/
public class DocumentFetcher {
+ private static final ITextFileBufferManager BUFFER_MANAGER = FileBuffers.getTextFileBufferManager();
+
private Map