added LineBackgroundPainter.java from CDT project as it has the same EPL

src/net/sourceforge/veditor/cdt/LineBackgroundPainter.java

+/*******************************************************************************
+ * Copyright (c) 2007, 2011 Wind River Systems, Inc. and others.
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ *     Anton Leherbauer (Wind River Systems) - initial API and implementation
+ *******************************************************************************/
+package com.elphel.vdt.veditor.cdt;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.jface.text.BadLocationException;
+import org.eclipse.jface.text.IDocument;
+import org.eclipse.jface.text.IPaintPositionManager;
+import org.eclipse.jface.text.IPainter;
+import org.eclipse.jface.text.IRegion;
+import org.eclipse.jface.text.ITextViewer;
+import org.eclipse.jface.text.ITextViewerExtension5;
+import org.eclipse.jface.text.Position;
+import org.eclipse.jface.text.TypedPosition;
+import org.eclipse.swt.custom.LineBackgroundEvent;
+import org.eclipse.swt.custom.LineBackgroundListener;
+import org.eclipse.swt.custom.StyledText;
+import org.eclipse.swt.graphics.Color;
+import org.eclipse.swt.graphics.Point;
+import org.eclipse.swt.graphics.Rectangle;
+
+/**
+ * A painter for configurable background painting a range of text lines.
+ * Replicates also the functionality of the
+ * {@link org.eclipse.jface.text.CursorLinePainter}
+ * because only one {@link LineBackgroundListener} is allowed
+ * per {@link StyledText} widget.
+ *
+ * @author anton.leherbauer@windriver.com
+ *
+ * @since 4.0
+ */
+public class LineBackgroundPainter implements IPainter, LineBackgroundListener {
+
+	/** The default position type for untyped positions */
+	private static final String DEFAULT_TYPE= "__default__"; //$NON-NLS-1$
+	/** The position type for the cursor line position */
+	private static final String CURSOR_LINE_TYPE= "__cursor_line__"; //$NON-NLS-1$
+
+	/** Manager for position changes */
+	private IPaintPositionManager fPositionManager;
+	/** Indicates whether this painter is active */
+	private boolean fIsActive= false;
+	/** The text viewer this painter is associated with */
+	private ITextViewer fTextViewer;
+	/** The viewer's widget */
+	private StyledText fTextWidget;
+	/** Text positions (cursor line position is always at index 0 */
+	private List<Position> fPositions= new ArrayList<Position>();
+	/** Cached text positions */
+	private List<Position> fLastPositions= new ArrayList<Position>();
+	/** Temporary changed positions */
+	private List<Position> fChangedPositions= new ArrayList<Position>();
+	/** Cursor line position */
+	private Position fCursorLine= new TypedPosition(0, 0, CURSOR_LINE_TYPE);
+	/** Saved cursor line position */
+	private Position fLastCursorLine= new Position(0, 0);
+	/** Enablement of the cursor line highlighting */
+	private boolean fCursorLineEnabled;
+	/** Whether cursor line highlighting is active */
+	private boolean fCursorLineActive;
+	/** Map of position type to color */
+	private Map<String, Color> fColorMap= new HashMap<String, Color>();
+
+	/**
+	 * Creates a new painter for the given text viewer.
+	 * @param textViewer
+	 */
+	public LineBackgroundPainter(ITextViewer textViewer) {
+		super();
+		fTextViewer= textViewer;
+		fTextWidget= textViewer.getTextWidget();
+		fPositions.add(fCursorLine);
+		fLastPositions.add(fLastCursorLine);
+	}
+
+	/**
+	 * Sets the color in which to draw the background of the given position type.
+	 *
+	 * @param positionType  the position type for which to specify the background color
+	 * @param color  the color in which to draw the background of the given position type
+	 */
+	public void setBackgroundColor(String positionType, Color color) {
+		fColorMap.put(positionType, color);
+	}
+
+	/**
+	 * Sets the color in which to draw the background of the cursor line.
+	 *
+	 * @param cursorLineColor the color in which to draw the background of the cursor line
+	 */
+	public void setCursorLineColor(Color cursorLineColor) {
+		fColorMap.put(CURSOR_LINE_TYPE, cursorLineColor);
+	}
+
+	/**
+	 * Sets the color in which to draw the background of untyped positions.
+	 *
+	 * @param color  the color in which to draw the background of untyped positions
+	 */
+	public void setDefaultColor(Color color) {
+		fColorMap.put(DEFAULT_TYPE, color);
+	}
+
+	/**
+	 * Enable/disable cursor line highlighting.
+	 *
+	 * @param enable
+	 */
+	public void enableCursorLine(boolean enable) {
+		fCursorLineEnabled= enable;
+		fCursorLineActive= enable;
+		if (fCursorLineActive) {
+			updateCursorLine();
+		}
+	}
+
+	/**
+	 * Set highlight positions. It is assumed that all positions
+	 * are up-to-date with respect to the text viewer document.
+	 *
+	 * @param positions a list of <code>Position</code>s
+	 */
+	public void setHighlightPositions(List<Position> positions) {
+		boolean isActive= fIsActive;
+		deactivate(isActive);
+		fPositions.clear();
+		fPositions.add(fCursorLine);
+		fPositions.addAll(positions);
+		if (isActive) {
+			activate(true);
+		}
+	}
+
+	/**
+	 * Add highlight positions. It is assumed that all positions
+	 * are up-to-date with respect to the text viewer document.
+	 *
+	 * @param positions a list of <code>Position</code>s
+	 */
+	public void addHighlightPositions(List<Position> positions) {
+		boolean isActive= fIsActive;
+		deactivate(isActive);
+		fPositions.addAll(positions);
+		if (isActive) {
+			activate(true);
+		}
+	}
+
+	/**
+	 * Remove highlight positions by identity.
+	 *
+	 * @param positions a list of <code>Position</code>s
+	 */
+	public void removeHighlightPositions(List<Position> positions) {
+		boolean isActive= fIsActive;
+		deactivate(isActive);
+		fPositions.removeAll(positions);
+		if (isActive) {
+			activate(true);
+		}
+	}
+
+	/**
+	 * Replace given highlight positions in one step.
+	 *
+	 * @param removePositions a list of <code>Position</code>s to remove
+	 * @param addPositions a list of <code>Position</code>s to add
+	 */
+	public void replaceHighlightPositions(List<Position> removePositions, List<Position> addPositions) {
+		boolean isActive= fIsActive;
+		deactivate(isActive);
+		fPositions.removeAll(removePositions);
+		fPositions.addAll(addPositions);
+		if (isActive) {
+			activate(true);
+		}
+	}
+
+	/**
+	 * Trigger redraw of managed positions.
+	 */
+	public void redraw() {
+		if(fIsActive) {
+			fTextWidget.redraw();
+		}
+	}
+
+	/**
+	 * Manage all positions.
+	 * @param positions
+	 */
+	private void managePositions(List<Position> positions) {
+		if (fPositionManager == null) {
+			return;
+		}
+		int sz= fPositions.size();
+		for (int i= 0; i < sz; ++i) {
+			Position position= positions.get(i);
+			fPositionManager.managePosition(position);
+		}
+	}
+
+	/**
+	 * Unmanage all positions.
+	 * @param positions
+	 */
+	private void unmanagePositions(List<Position> positions) {
+		if (fPositionManager == null) {
+			return;
+		}
+		int sz= fPositions.size();
+		for (int i= 0; i < sz; ++i) {
+			Position position= positions.get(i);
+			fPositionManager.unmanagePosition(position);
+		}
+	}
+
+	/*
+	 * @see org.eclipse.jface.text.IPainter#dispose()
+	 */
+	@Override
+	public void dispose() {
+		// no deactivate!
+		fIsActive= false;
+		fTextViewer= null;
+		fTextWidget= null;
+		fCursorLine= null;
+		fLastCursorLine= null;
+		fPositions= null;
+		fLastPositions= null;
+		fChangedPositions= null;
+		fColorMap= null;
+	}
+
+	/**
+	 * Query whether this painter is already disposed.
+	 * @return <code>true</code> if the painter is disposed
+	 */
+	public boolean isDisposed() {
+		return fTextViewer == null;
+	}
+
+	/*
+	 * @see org.eclipse.jface.text.IPainter#paint(int)
+	 */
+	@Override
+	public void paint(int reason) {
+		IDocument document= fTextViewer.getDocument();
+		if (document == null) {
+			deactivate(false);
+			return;
+		}
+		activate(false);
+
+		if (fCursorLineEnabled) {
+			// check selection
+			StyledText textWidget= fTextViewer.getTextWidget();
+			Point selection= textWidget.getSelection();
+			int startLine= textWidget.getLineAtOffset(selection.x);
+			int endLine= textWidget.getLineAtOffset(selection.y);
+			if (startLine != endLine) {
+				redrawPositions(Collections.singletonList(fLastCursorLine));
+				fCursorLineActive= false;
+			} else {
+				fCursorLineActive= true;
+			}
+			if (fCursorLineActive) {
+				// redraw in case of text changes prior to update of current cursor line
+				if (!fLastCursorLine.equals(fCursorLine)) {
+					redrawPositions(Collections.singletonList(fLastCursorLine));
+					fLastCursorLine.offset= fCursorLine.offset;
+					fLastCursorLine.length= fCursorLine.length;
+				}
+				updateCursorLine();
+			}
+		}
+		List<Position> changedPositions= getChangedPositions();
+		if (changedPositions != null) {
+			redrawPositions(changedPositions);
+			updatePositions();
+			redrawPositions(changedPositions);
+		}
+	}
+
+	/**
+	 * Activate the painter.
+	 * @param redraw
+	 */
+	private void activate(boolean redraw) {
+		if (!fIsActive) {
+			fIsActive= true;
+			fTextWidget.addLineBackgroundListener(this);
+			if (redraw) {
+				if (fCursorLineActive) {
+					updateCursorLine();
+				}
+				updatePositions();
+				redrawPositions(fPositions);
+			}
+			managePositions(fPositions);
+		}
+	}
+
+	/**
+	 * Copy positions from the current position list to the last position list.
+	 */
+	private void updatePositions() {
+		int sz= fPositions.size();
+		for (int i= 0; i < sz; ++i) {
+			Position position= fPositions.get(i);
+			Position copy;
+			if (i == fLastPositions.size()) {
+				copy= new Position(position.offset, position.length);
+				copy.isDeleted= position.isDeleted;
+				fLastPositions.add(copy);
+			} else {
+				copy= fLastPositions.get(i);
+				copy.offset= position.offset;
+				copy.length= position.length;
+				copy.isDeleted= position.isDeleted;
+			}
+			position.isDeleted= false;
+		}
+		int diff= fLastPositions.size() - sz;
+		while (diff > 0) {
+			--diff;
+			fLastPositions.remove(sz + diff);
+		}
+	}
+
+	/**
+	 * Check which positions have changed since last redraw.
+	 * @return a list of changed positions or <code>null</code> if none changed.
+	 */
+	private List<Position> getChangedPositions() {
+		if (fLastPositions.size() != fPositions.size()) {
+			return fLastPositions;
+		}
+		List<Position> changedPositions= null;
+		for (int i= 0, sz= fPositions.size(); i < sz; ++i) {
+			Position previous= fLastPositions.get(i);
+			Position current= fPositions.get(i);
+			if (!previous.equals(current)) {
+				if (changedPositions == null) {
+					changedPositions= fChangedPositions;
+					changedPositions.clear();
+				}
+				changedPositions.add(previous);
+			}
+		}
+		return changedPositions;
+	}
+
+	/**
+	 * Trigger redraw of given text positions.
+	 *
+	 * @param positions
+	 */
+	private void redrawPositions(List<Position> positions) {
+		// TextViewer.getTopIndexStartOffset is buggy
+		// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=174419
+//		final int minOffset= fTextViewer.getTopIndexStartOffset();
+		final int minOffset= getTopIndexStartOffset();
+		final int maxOffset= fTextViewer.getBottomIndexEndOffset()+3;
+		Rectangle clientArea= fTextWidget.getClientArea();
+		int width= clientArea.width + fTextWidget.getHorizontalPixel();
+		int lineHeight= fTextWidget.getLineHeight();
+		for (int i= 0, sz= positions.size(); i < sz; ++i) {
+			Position position= positions.get(i);
+			// if the position that is about to be drawn was deleted then we can't
+			if (position.isDeleted()) {
+				continue;
+			}
+			// check if position overlaps with visible area
+			if (!position.overlapsWith(minOffset, maxOffset - minOffset + 1)) {
+				continue;
+			}
+			int widgetOffset= getWidgetOffset(position.offset);
+			if (widgetOffset < 0 || widgetOffset > fTextWidget.getCharCount()) {
+				continue;
+			}
+			// TLETODO [performance] SyledText.getLocationAtOffset() is very expensive
+			Point upperLeft= fTextWidget.getLocationAtOffset(widgetOffset);
+			int upperY= Math.max(Math.min(upperLeft.y, clientArea.height), 0);
+			int height;
+			if (position.length == 0) {
+				height= lineHeight;
+			} else {
+				int widgetEndOffset= Math.min(widgetOffset + position.length, fTextWidget.getCharCount());
+				Point lowerRight= fTextWidget.getLocationAtOffset(widgetEndOffset);
+				int lowerY= Math.min(lowerRight.y + lineHeight, clientArea.height);
+				height= lowerY - upperY;
+			}
+			if (height > 0) {
+				fTextWidget.redraw(0, upperY, width, height, false);
+			}
+		}
+	}
+
+	/**
+	 * Workaround for https://bugs.eclipse.org/bugs/show_bug.cgi?id=174419
+	 * @return the offset of the topmost visible line
+	 * @see ITextViewer#getTopIndexStartOffset()
+	 */
+	private int getTopIndexStartOffset() {
+		if (fTextWidget != null) {
+			int top= fTextWidget.getTopIndex();
+			// https://bugs.eclipse.org/bugs/show_bug.cgi?id=183653
+			top= fTextWidget.getOffsetAtLine(Math.min(fTextWidget.getLineCount() - 1, top));
+			if (top >= 0) {
+				return getDocumentOffset(top);
+			}
+		}
+		return -1;
+	}
+
+	/*
+	 * @see org.eclipse.jface.text.IPainter#deactivate(boolean)
+	 */
+	@Override
+	public void deactivate(boolean redraw) {
+		if (fIsActive) {
+			fIsActive= false;
+			fTextWidget.removeLineBackgroundListener(this);
+			if (redraw) {
+				redrawPositions(fLastPositions);
+			}
+			unmanagePositions(fPositions);
+		}
+	}
+
+	/*
+	 * @see org.eclipse.jface.text.IPainter#setPositionManager(org.eclipse.jface.text.IPaintPositionManager)
+	 */
+	@Override
+	public void setPositionManager(IPaintPositionManager manager) {
+		fPositionManager= manager;
+	}
+
+	/**
+	 * Convert a document offset to the corresponding widget offset.
+	 * @param documentOffset
+	 * @return widget offset
+	 */
+	private int getWidgetOffset(int documentOffset) {
+		if (fTextViewer instanceof ITextViewerExtension5) {
+			ITextViewerExtension5 extension= (ITextViewerExtension5)fTextViewer;
+			return extension.modelOffset2WidgetOffset(documentOffset);
+		}
+		IRegion visible= fTextViewer.getVisibleRegion();
+		int widgetOffset= documentOffset - visible.getOffset();
+		if (widgetOffset > visible.getLength()) {
+			return -1;
+		}
+		return widgetOffset;
+	}
+
+	/**
+	 * Convert a widget offset to the corresponding document offset.
+	 * @param widgetOffset
+	 * @return document offset
+	 */
+	private int getDocumentOffset(int widgetOffset) {
+		if (fTextViewer instanceof ITextViewerExtension5) {
+			ITextViewerExtension5 extension= (ITextViewerExtension5)fTextViewer;
+			return extension.widgetOffset2ModelOffset(widgetOffset);
+		}
+		IRegion visible= fTextViewer.getVisibleRegion();
+		if (widgetOffset > visible.getLength()) {
+			return -1;
+		}
+		return widgetOffset + visible.getOffset();
+	}
+
+	/*
+	 * @see org.eclipse.swt.custom.LineBackgroundListener#lineGetBackground(org.eclipse.swt.custom.LineBackgroundEvent)
+	 */
+	@Override
+	public void lineGetBackground(LineBackgroundEvent event) {
+		if (fTextWidget != null) {
+			Position match= findIncludingPosition(getDocumentOffset(event.lineOffset));
+			if (match != null) {
+				Color color= getColorForPosition(match);
+				if (color != null) {
+					event.lineBackground= color;
+				}
+			}
+		}
+	}
+
+	/**
+	 * Get the color associated with given position.
+	 * @param position
+	 * @return the color associated with the position type
+	 */
+	private Color getColorForPosition(Position position) {
+		if (position == fCursorLine) {
+			if (fCursorLine.length == 0) {
+				return fColorMap.get(CURSOR_LINE_TYPE);
+			}
+		} else {
+			if (position instanceof TypedPosition) {
+				String type= ((TypedPosition)position).getType();
+				return fColorMap.get(type);
+			}
+			return fColorMap.get(DEFAULT_TYPE);
+		}
+		return null;
+	}
+
+	/**
+	 * Find position which includes the (document-)offset.
+	 * @param offset
+	 * @return the first position including the offset or <code>null</code>.
+	 */
+	private Position findIncludingPosition(int offset) {
+		// TLETODO [performance] Use binary search?
+		for (int i= fCursorLineActive ? 0 : 1, sz= fPositions.size(); i < sz; ++i) {
+			Position position= fPositions.get(i);
+			if (position.offset == offset || position.includes(offset)) {
+				return position;
+			}
+		}
+		return null;
+	}
+
+	/**
+	 * Updates the position of the cursor line.
+	 */
+	private void updateCursorLine() {
+		try {
+			IDocument document= fTextViewer.getDocument();
+			if (document != null) {
+				int lineNumber= document.getLineOfOffset(getDocumentOffset(fTextWidget.getCaretOffset()));
+
+				fCursorLine.isDeleted= false;
+				fCursorLine.offset= document.getLineOffset(lineNumber);
+				fCursorLine.length= 0;
+			}
+		} catch (BadLocationException e) {
+			// gracefully ignored
+		}
+	}
+}