/*
* Copyright (c) 1998, 2006, 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.
*/
/*
* (C) Copyright IBM Corp. 1998, All Rights Reserved
*/
package sun.font;
import java.awt.BasicStroke;
import java.awt.Graphics2D;
import java.awt.Shape;
import java.awt.Stroke;
import java.awt.geom.GeneralPath;
import java.awt.geom.Line2D;
import java.awt.font.TextAttribute;
import java.util.concurrent.ConcurrentHashMap;
/**
* This class provides drawing and bounds-measurement of
* underlines. Additionally, it has a factory method for
* obtaining underlines from values of underline attributes.
*/
abstract class Underline {
/**
* Draws the underline into g2d. The thickness should be obtained
* from a LineMetrics object. Note that some underlines ignore the
* thickness parameter.
* The underline is drawn from (x1, y) to (x2, y).
*/
abstract void drawUnderline(Graphics2D g2d,
float thickness,
float x1,
float x2,
float y);
/**
* Returns the bottom of the bounding rectangle for this underline.
*/
abstract float getLowerDrawLimit(float thickness);
/**
* Returns a Shape representing the underline. The thickness should be obtained
* from a LineMetrics object. Note that some underlines ignore the
* thickness parameter.
*/
abstract Shape getUnderlineShape(float thickness,
float x1,
float x2,
float y);
// Implementation of underline for standard and Input Method underlines.
// These classes are private.
// IM Underlines ignore thickness param, and instead use
// DEFAULT_THICKNESS
private static final float DEFAULT_THICKNESS = 1.0f;
// StandardUnderline's constructor takes a boolean param indicating
// whether to override the default thickness. These values clarify
// the semantics of the parameter.
private static final boolean USE_THICKNESS = true;
private static final boolean IGNORE_THICKNESS = false;
// Implementation of standard underline and all input method underlines
// except UNDERLINE_LOW_GRAY.
private static final class StandardUnderline extends Underline {
// the amount by which to move the underline
private float shift;
// the actual line thickness is this value times
// the requested thickness
private float thicknessMultiplier;
// if non-null, underline is drawn with a BasicStroke
// with this dash pattern
private float[] dashPattern;
// if false, all underlines are DEFAULT_THICKNESS thick
// if true, use thickness param
private boolean useThickness;
// cached BasicStroke
private BasicStroke cachedStroke;
StandardUnderline(float shift,
float thicknessMultiplier,
float[] dashPattern,
boolean useThickness) {
this.shift = shift;
this.thicknessMultiplier = thicknessMultiplier;
this.dashPattern = dashPattern;
this.useThickness = useThickness;
this.cachedStroke = null;
}
private BasicStroke createStroke(float lineThickness) {
if (dashPattern == null) {
return new BasicStroke(lineThickness);
}
else {
return new BasicStroke(lineThickness,
BasicStroke.CAP_BUTT,
BasicStroke.JOIN_MITER,
10.0f,
dashPattern,
0);
}
}
private float getLineThickness(float thickness) {
if (useThickness) {
return thickness * thicknessMultiplier;
}
else {
return DEFAULT_THICKNESS * thicknessMultiplier;
}
}
private Stroke getStroke(float thickness) {
float lineThickness = getLineThickness(thickness);
BasicStroke stroke = cachedStroke;
if (stroke == null ||
stroke.getLineWidth() != lineThickness) {
stroke = createStroke(lineThickness);
cachedStroke = stroke;
}
return stroke;
}
void drawUnderline(Graphics2D g2d,
float thickness,
float x1,
float x2,
float y) {
Stroke saveStroke = g2d.getStroke();
g2d.setStroke(getStroke(thickness));
g2d.draw(new Line2D.Float(x1, y + shift, x2, y + shift));
g2d.setStroke(saveStroke);
}
float getLowerDrawLimit(float thickness) {
return shift + getLineThickness(thickness);
}
Shape getUnderlineShape(float thickness,
float x1,
float x2,
float y) {
Stroke ulStroke = getStroke(thickness);
Line2D line = new Line2D.Float(x1, y + shift, x2, y + shift);
return ulStroke.createStrokedShape(line);
}
}
// Implementation of UNDERLINE_LOW_GRAY.
private static class IMGrayUnderline extends Underline {
private BasicStroke stroke;
IMGrayUnderline() {
stroke = new BasicStroke(DEFAULT_THICKNESS,
BasicStroke.CAP_BUTT,
BasicStroke.JOIN_MITER,
10.0f,
new float[] {1, 1},
0);
}
void drawUnderline(Graphics2D g2d,
float thickness,
float x1,
float x2,
float y) {
Stroke saveStroke = g2d.getStroke();
g2d.setStroke(stroke);
Line2D.Float drawLine = new Line2D.Float(x1, y, x2, y);
g2d.draw(drawLine);
drawLine.y1 += DEFAULT_THICKNESS;
drawLine.y2 += DEFAULT_THICKNESS;
drawLine.x1 += DEFAULT_THICKNESS;
g2d.draw(drawLine);
g2d.setStroke(saveStroke);
}
float getLowerDrawLimit(float thickness) {
return DEFAULT_THICKNESS * 2;
}
Shape getUnderlineShape(float thickness,
float x1,
float x2,
float y) {
GeneralPath gp = new GeneralPath();
Line2D.Float line = new Line2D.Float(x1, y, x2, y);
gp.append(stroke.createStrokedShape(line), false);
line.y1 += DEFAULT_THICKNESS;
line.y2 += DEFAULT_THICKNESS;
line.x1 += DEFAULT_THICKNESS;
gp.append(stroke.createStrokedShape(line), false);
return gp;
}
}
// Keep a map of underlines, one for each type
// of underline. The Underline objects are Flyweights
// (shared across multiple clients), so they should be immutable.
// If this implementation changes then clone underline
// instances in getUnderline before returning them.
private static final ConcurrentHashMap<Object, Underline>
UNDERLINES = new ConcurrentHashMap<Object, Underline>(6);
private static final Underline[] UNDERLINE_LIST;
static {
Underline[] uls = new Underline[6];
uls[0] = new StandardUnderline(0, 1, null, USE_THICKNESS);
UNDERLINES.put(TextAttribute.UNDERLINE_ON, uls[0]);
uls[1] = new StandardUnderline(1, 1, null, IGNORE_THICKNESS);
UNDERLINES.put(TextAttribute.UNDERLINE_LOW_ONE_PIXEL, uls[1]);
uls[2] = new StandardUnderline(1, 2, null, IGNORE_THICKNESS);
UNDERLINES.put(TextAttribute.UNDERLINE_LOW_TWO_PIXEL, uls[2]);
uls[3] = new StandardUnderline(1, 1, new float[] { 1, 1 }, IGNORE_THICKNESS);
UNDERLINES.put(TextAttribute.UNDERLINE_LOW_DOTTED, uls[3]);
uls[4] = new IMGrayUnderline();
UNDERLINES.put(TextAttribute.UNDERLINE_LOW_GRAY, uls[4]);
uls[5] = new StandardUnderline(1, 1, new float[] { 4, 4 }, IGNORE_THICKNESS);
UNDERLINES.put(TextAttribute.UNDERLINE_LOW_DASHED, uls[5]);
UNDERLINE_LIST = uls;
}
/**
* Return the Underline for the given value of
* TextAttribute.INPUT_METHOD_UNDERLINE or
* TextAttribute.UNDERLINE.
* If value is not an input method underline value or
* TextAttribute.UNDERLINE_ON, null is returned.
*/
static Underline getUnderline(Object value) {
if (value == null) {
return null;
}
return (Underline) UNDERLINES.get(value);
}
static Underline getUnderline(int index) {
return index < 0 ? null : UNDERLINE_LIST[index];
}
}