Back to index...

	/*
	* Copyright (c) 1997, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/
	package javax.swing.text;

	import java.util.Vector;
	import java.awt.*;
	import javax.swing.plaf.*;
	import javax.swing.*;

	/**
	* Implements the Highlighter interfaces. Implements a simple highlight
	* painter that renders in a solid color.
	*
	* @author Timothy Prinzing
	* @see Highlighter
	*/
	public class DefaultHighlighter extends LayeredHighlighter {

	/**
	* Creates a new DefaultHighlighther object.
	*/
	public DefaultHighlighter() {
	drawsLayeredHighlights = true;
	}

	// ---- Highlighter methods ----------------------------------------------

	/**
	* Renders the highlights.
	*
	* @param g the graphics context
	*/
	public void paint(Graphics g) {
	// PENDING(prinz) - should cull ranges not visible
	int len = highlights.size();
	for (int i = 0; i < len; i++) {
	HighlightInfo info = highlights.elementAt(i);
	if (!(info instanceof LayeredHighlightInfo)) {
	// Avoid allocing unless we need it.
	Rectangle a = component.getBounds();
	Insets insets = component.getInsets();
	a.x = insets.left;
	a.y = insets.top;
	a.width -= insets.left + insets.right;
	a.height -= insets.top + insets.bottom;
	for (; i < len; i++) {
	info = highlights.elementAt(i);
	if (!(info instanceof LayeredHighlightInfo)) {
	Highlighter.HighlightPainter p = info.getPainter();
	p.paint(g, info.getStartOffset(), info.getEndOffset(),
	a, component);
	}
	}
	}
	}
	}

	/**
	* Called when the UI is being installed into the
	* interface of a JTextComponent. Installs the editor, and
	* removes any existing highlights.
	*
	* @param c the editor component
	* @see Highlighter#install
	*/
	public void install(JTextComponent c) {
	component = c;
	removeAllHighlights();
	}

	/**
	* Called when the UI is being removed from the interface of
	* a JTextComponent.
	*
	* @param c the component
	* @see Highlighter#deinstall
	*/
	public void deinstall(JTextComponent c) {
	component = null;
	}

	/**
	* Adds a highlight to the view. Returns a tag that can be used
	* to refer to the highlight.
	*
	* @param p0 the start offset of the range to highlight >= 0
	* @param p1 the end offset of the range to highlight >= p0
	* @param p the painter to use to actually render the highlight
	* @return an object that can be used as a tag
	* to refer to the highlight
	* @exception BadLocationException if the specified location is invalid
	*/
	public Object addHighlight(int p0, int p1, Highlighter.HighlightPainter p) throws BadLocationException {
	if (p0 < 0) {
	throw new BadLocationException("Invalid start offset", p0);
	}

	if (p1 < p0) {
	throw new BadLocationException("Invalid end offset", p1);
	}

	Document doc = component.getDocument();
	HighlightInfo i = (getDrawsLayeredHighlights() &&
	(p instanceof LayeredHighlighter.LayerPainter)) ?
	new LayeredHighlightInfo() : new HighlightInfo();
	i.painter = p;
	i.p0 = doc.createPosition(p0);
	i.p1 = doc.createPosition(p1);
	highlights.addElement(i);
	safeDamageRange(p0, p1);
	return i;
	}

	/**
	* Removes a highlight from the view.
	*
	* @param tag the reference to the highlight
	*/
	public void removeHighlight(Object tag) {
	if (tag instanceof LayeredHighlightInfo) {
	LayeredHighlightInfo lhi = (LayeredHighlightInfo)tag;
	if (lhi.width > 0 && lhi.height > 0) {
	component.repaint(lhi.x, lhi.y, lhi.width, lhi.height);
	}
	}
	else {
	HighlightInfo info = (HighlightInfo) tag;
	safeDamageRange(info.p0, info.p1);
	}
	highlights.removeElement(tag);
	}

	/**
	* Removes all highlights.
	*/
	public void removeAllHighlights() {
	TextUI mapper = component.getUI();
	if (getDrawsLayeredHighlights()) {
	int len = highlights.size();
	if (len != 0) {
	int minX = 0;
	int minY = 0;
	int maxX = 0;
	int maxY = 0;
	int p0 = -1;
	int p1 = -1;
	for (int i = 0; i < len; i++) {
	HighlightInfo hi = highlights.elementAt(i);
	if (hi instanceof LayeredHighlightInfo) {
	LayeredHighlightInfo info = (LayeredHighlightInfo)hi;
	minX = Math.min(minX, info.x);
	minY = Math.min(minY, info.y);
	maxX = Math.max(maxX, info.x + info.width);
	maxY = Math.max(maxY, info.y + info.height);
	}
	else {
	if (p0 == -1) {
	p0 = hi.p0.getOffset();
	p1 = hi.p1.getOffset();
	}
	else {
	p0 = Math.min(p0, hi.p0.getOffset());
	p1 = Math.max(p1, hi.p1.getOffset());
	}
	}
	}
	if (minX != maxX && minY != maxY) {
	component.repaint(minX, minY, maxX - minX, maxY - minY);
	}
	if (p0 != -1) {
	try {
	safeDamageRange(p0, p1);
	} catch (BadLocationException e) {}
	}
	highlights.removeAllElements();
	}
	}
	else if (mapper != null) {
	int len = highlights.size();
	if (len != 0) {
	int p0 = Integer.MAX_VALUE;
	int p1 = 0;
	for (int i = 0; i < len; i++) {
	HighlightInfo info = highlights.elementAt(i);
	p0 = Math.min(p0, info.p0.getOffset());
	p1 = Math.max(p1, info.p1.getOffset());
	}
	try {
	safeDamageRange(p0, p1);
	} catch (BadLocationException e) {}

	highlights.removeAllElements();
	}
	}
	}

	/**
	* Changes a highlight.
	*
	* @param tag the highlight tag
	* @param p0 the beginning of the range >= 0
	* @param p1 the end of the range >= p0
	* @exception BadLocationException if the specified location is invalid
	*/
	public void changeHighlight(Object tag, int p0, int p1) throws BadLocationException {
	if (p0 < 0) {
	throw new BadLocationException("Invalid beginning of the range", p0);
	}

	if (p1 < p0) {
	throw new BadLocationException("Invalid end of the range", p1);
	}

	Document doc = component.getDocument();
	if (tag instanceof LayeredHighlightInfo) {
	LayeredHighlightInfo lhi = (LayeredHighlightInfo)tag;
	if (lhi.width > 0 && lhi.height > 0) {
	component.repaint(lhi.x, lhi.y, lhi.width, lhi.height);
	}
	// Mark the highlights region as invalid, it will reset itself
	// next time asked to paint.
	lhi.width = lhi.height = 0;
	lhi.p0 = doc.createPosition(p0);
	lhi.p1 = doc.createPosition(p1);
	safeDamageRange(Math.min(p0, p1), Math.max(p0, p1));
	}
	else {
	HighlightInfo info = (HighlightInfo) tag;
	int oldP0 = info.p0.getOffset();
	int oldP1 = info.p1.getOffset();
	if (p0 == oldP0) {
	safeDamageRange(Math.min(oldP1, p1),
	Math.max(oldP1, p1));
	} else if (p1 == oldP1) {
	safeDamageRange(Math.min(p0, oldP0),
	Math.max(p0, oldP0));
	} else {
	safeDamageRange(oldP0, oldP1);
	safeDamageRange(p0, p1);
	}
	info.p0 = doc.createPosition(p0);
	info.p1 = doc.createPosition(p1);
	}
	}

	/**
	* Makes a copy of the highlights. Does not actually clone each highlight,
	* but only makes references to them.
	*
	* @return the copy
	* @see Highlighter#getHighlights
	*/
	public Highlighter.Highlight[] getHighlights() {
	int size = highlights.size();
	if (size == 0) {
	return noHighlights;
	}
	Highlighter.Highlight[] h = new Highlighter.Highlight[size];
	highlights.copyInto(h);
	return h;
	}

	/**
	* When leaf Views (such as LabelView) are rendering they should
	* call into this method. If a highlight is in the given region it will
	* be drawn immediately.
	*
	* @param g Graphics used to draw
	* @param p0 starting offset of view
	* @param p1 ending offset of view
	* @param viewBounds Bounds of View
	* @param editor JTextComponent
	* @param view View instance being rendered
	*/
	public void paintLayeredHighlights(Graphics g, int p0, int p1,
	Shape viewBounds,
	JTextComponent editor, View view) {
	for (int counter = highlights.size() - 1; counter >= 0; counter--) {
	HighlightInfo tag = highlights.elementAt(counter);
	if (tag instanceof LayeredHighlightInfo) {
	LayeredHighlightInfo lhi = (LayeredHighlightInfo)tag;
	int start = lhi.getStartOffset();
	int end = lhi.getEndOffset();
	if ((p0 < start && p1 > start) \|\|
	(p0 >= start && p0 < end)) {
	lhi.paintLayeredHighlights(g, p0, p1, viewBounds,
	editor, view);
	}
	}
	}
	}

	/**
	* Queues damageRange() call into event dispatch thread
	* to be sure that views are in consistent state.
	*/
	private void safeDamageRange(final Position p0, final Position p1) {
	safeDamager.damageRange(p0, p1);
	}

	/**
	* Queues damageRange() call into event dispatch thread
	* to be sure that views are in consistent state.
	*/
	private void safeDamageRange(int a0, int a1) throws BadLocationException {
	Document doc = component.getDocument();
	safeDamageRange(doc.createPosition(a0), doc.createPosition(a1));
	}

	/**
	* If true, highlights are drawn as the Views draw the text. That is
	* the Views will call into <code>paintLayeredHighlight</code> which
	* will result in a rectangle being drawn before the text is drawn
	* (if the offsets are in a highlighted region that is). For this to
	* work the painter supplied must be an instance of
	* LayeredHighlightPainter.
	*/
	public void setDrawsLayeredHighlights(boolean newValue) {
	drawsLayeredHighlights = newValue;
	}

	public boolean getDrawsLayeredHighlights() {
	return drawsLayeredHighlights;
	}

	// ---- member variables --------------------------------------------

	private final static Highlighter.Highlight[] noHighlights =
	new Highlighter.Highlight[0];
	private Vector<HighlightInfo> highlights = new Vector<HighlightInfo>();
	private JTextComponent component;
	private boolean drawsLayeredHighlights;
	private SafeDamager safeDamager = new SafeDamager();


	/**
	* Default implementation of LayeredHighlighter.LayerPainter that can
	* be used for painting highlights.
	* <p>
	* As of 1.4 this field is final.
	*/
	public static final LayeredHighlighter.LayerPainter DefaultPainter = new DefaultHighlightPainter(null);


	/**
	* Simple highlight painter that fills a highlighted area with
	* a solid color.
	*/
	public static class DefaultHighlightPainter extends LayeredHighlighter.LayerPainter {

	/**
	* Constructs a new highlight painter. If <code>c</code> is null,
	* the JTextComponent will be queried for its selection color.
	*
	* @param c the color for the highlight
	*/
	public DefaultHighlightPainter(Color c) {
	color = c;
	}

	/**
	* Returns the color of the highlight.
	*
	* @return the color
	*/
	public Color getColor() {
	return color;
	}

	// --- HighlightPainter methods ---------------------------------------

	/**
	* Paints a highlight.
	*
	* @param g the graphics context
	* @param offs0 the starting model offset >= 0
	* @param offs1 the ending model offset >= offs1
	* @param bounds the bounding box for the highlight
	* @param c the editor
	*/
	public void paint(Graphics g, int offs0, int offs1, Shape bounds, JTextComponent c) {
	Rectangle alloc = bounds.getBounds();
	try {
	// --- determine locations ---
	TextUI mapper = c.getUI();
	Rectangle p0 = mapper.modelToView(c, offs0);
	Rectangle p1 = mapper.modelToView(c, offs1);

	// --- render ---
	Color color = getColor();

	if (color == null) {
	g.setColor(c.getSelectionColor());
	}
	else {
	g.setColor(color);
	}
	if (p0.y == p1.y) {
	// same line, render a rectangle
	Rectangle r = p0.union(p1);
	g.fillRect(r.x, r.y, r.width, r.height);
	} else {
	// different lines
	int p0ToMarginWidth = alloc.x + alloc.width - p0.x;
	g.fillRect(p0.x, p0.y, p0ToMarginWidth, p0.height);
	if ((p0.y + p0.height) != p1.y) {
	g.fillRect(alloc.x, p0.y + p0.height, alloc.width,
	p1.y - (p0.y + p0.height));
	}
	g.fillRect(alloc.x, p1.y, (p1.x - alloc.x), p1.height);
	}
	} catch (BadLocationException e) {
	// can't render
	}
	}

	// --- LayerPainter methods ----------------------------
	/**
	* Paints a portion of a highlight.
	*
	* @param g the graphics context
	* @param offs0 the starting model offset >= 0
	* @param offs1 the ending model offset >= offs1
	* @param bounds the bounding box of the view, which is not
	* necessarily the region to paint.
	* @param c the editor
	* @param view View painting for
	* @return region drawing occurred in
	*/
	public Shape paintLayer(Graphics g, int offs0, int offs1,
	Shape bounds, JTextComponent c, View view) {
	Color color = getColor();

	if (color == null) {
	g.setColor(c.getSelectionColor());
	}
	else {
	g.setColor(color);
	}

	Rectangle r;

	if (offs0 == view.getStartOffset() &&
	offs1 == view.getEndOffset()) {
	// Contained in view, can just use bounds.
	if (bounds instanceof Rectangle) {
	r = (Rectangle) bounds;
	}
	else {
	r = bounds.getBounds();
	}
	}
	else {
	// Should only render part of View.
	try {
	// --- determine locations ---
	Shape shape = view.modelToView(offs0, Position.Bias.Forward,
	offs1,Position.Bias.Backward,
	bounds);
	r = (shape instanceof Rectangle) ?
	(Rectangle)shape : shape.getBounds();
	} catch (BadLocationException e) {
	// can't render
	r = null;
	}
	}

	if (r != null) {
	// If we are asked to highlight, we should draw something even
	// if the model-to-view projection is of zero width (6340106).
	r.width = Math.max(r.width, 1);

	g.fillRect(r.x, r.y, r.width, r.height);
	}

	return r;
	}

	private Color color;

	}


	class HighlightInfo implements Highlighter.Highlight {

	public int getStartOffset() {
	return p0.getOffset();
	}

	public int getEndOffset() {
	return p1.getOffset();
	}

	public Highlighter.HighlightPainter getPainter() {
	return painter;
	}

	Position p0;
	Position p1;
	Highlighter.HighlightPainter painter;
	}


	/**
	* LayeredHighlightPainter is used when a drawsLayeredHighlights is
	* true. It maintains a rectangle of the region to paint.
	*/
	class LayeredHighlightInfo extends HighlightInfo {

	void union(Shape bounds) {
	if (bounds == null)
	return;

	Rectangle alloc;
	if (bounds instanceof Rectangle) {
	alloc = (Rectangle)bounds;
	}
	else {
	alloc = bounds.getBounds();
	}
	if (width == 0 \|\| height == 0) {
	x = alloc.x;
	y = alloc.y;
	width = alloc.width;
	height = alloc.height;
	}
	else {
	width = Math.max(x + width, alloc.x + alloc.width);
	height = Math.max(y + height, alloc.y + alloc.height);
	x = Math.min(x, alloc.x);
	width -= x;
	y = Math.min(y, alloc.y);
	height -= y;
	}
	}

	/**
	* Restricts the region based on the receivers offsets and messages
	* the painter to paint the region.
	*/
	void paintLayeredHighlights(Graphics g, int p0, int p1,
	Shape viewBounds, JTextComponent editor,
	View view) {
	int start = getStartOffset();
	int end = getEndOffset();
	// Restrict the region to what we represent
	p0 = Math.max(start, p0);
	p1 = Math.min(end, p1);
	// Paint the appropriate region using the painter and union
	// the effected region with our bounds.
	union(((LayeredHighlighter.LayerPainter)painter).paintLayer
	(g, p0, p1, viewBounds, editor, view));
	}

	int x;
	int y;
	int width;
	int height;
	}

	/**
	* This class invokes <code>mapper.damageRange</code> in
	* EventDispatchThread. The only one instance per Highlighter
	* is cretaed. When a number of ranges should be damaged
	* it collects them into queue and damages
	* them in consecutive order in <code>run</code>
	* call.
	*/
	class SafeDamager implements Runnable {
	private Vector<Position> p0 = new Vector<Position>(10);
	private Vector<Position> p1 = new Vector<Position>(10);
	private Document lastDoc = null;

	/**
	* Executes range(s) damage and cleans range queue.
	*/
	public synchronized void run() {
	if (component != null) {
	TextUI mapper = component.getUI();
	if (mapper != null && lastDoc == component.getDocument()) {
	// the Document should be the same to properly
	// display highlights
	int len = p0.size();
	for (int i = 0; i < len; i++){
	mapper.damageRange(component,
	p0.get(i).getOffset(),
	p1.get(i).getOffset());
	}
	}
	}
	p0.clear();
	p1.clear();

	// release reference
	lastDoc = null;
	}

	/**
	* Adds the range to be damaged into the range queue. If the
	* range queue is empty (the first call or run() was already
	* invoked) then adds this class instance into EventDispatch
	* queue.
	*
	* The method also tracks if the current document changed or
	* component is null. In this case it removes all ranges added
	* before from range queue.
	*/
	public synchronized void damageRange(Position pos0, Position pos1) {
	if (component == null) {
	p0.clear();
	lastDoc = null;
	return;
	}

	boolean addToQueue = p0.isEmpty();
	Document curDoc = component.getDocument();
	if (curDoc != lastDoc) {
	if (!p0.isEmpty()) {
	p0.clear();
	p1.clear();
	}
	lastDoc = curDoc;
	}
	p0.add(pos0);
	p1.add(pos1);

	if (addToQueue) {
	SwingUtilities.invokeLater(this);
	}
	}
	}
	}

Back to index...