Back to index...

	/*
	* Copyright (c) 1998, 2005, 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-2003, All Rights Reserved
	*
	*/

	package sun.font;

	import java.awt.Font;
	import java.awt.Graphics2D;
	import java.awt.Rectangle;
	import java.awt.Shape;
	import java.awt.font.FontRenderContext;
	import java.awt.font.LineMetrics;
	import java.awt.font.GraphicAttribute;
	import java.awt.font.GlyphJustificationInfo;
	import java.awt.geom.AffineTransform;
	import java.awt.geom.GeneralPath;
	import java.awt.geom.Rectangle2D;
	import java.text.Bidi;
	import java.util.Map;

	public final class GraphicComponent implements TextLineComponent,
	Decoration.Label {

	public static final float GRAPHIC_LEADING = 2;

	private GraphicAttribute graphic;
	private int graphicCount;
	private int[] charsLtoV; // possibly null
	private byte[] levels; // possibly null

	// evaluated in computeVisualBounds
	private Rectangle2D visualBounds = null;

	// used everywhere so we'll cache it
	private float graphicAdvance;

	private AffineTransform baseTx;

	private CoreMetrics cm;
	private Decoration decorator;


	/**
	* Create a new GraphicComponent. start and limit are indices
	* into charLtoV and levels. charsLtoV and levels may be adopted.
	*/
	public GraphicComponent(GraphicAttribute graphic,
	Decoration decorator,
	int[] charsLtoV,
	byte[] levels,
	int start,
	int limit,
	AffineTransform baseTx) {

	if (limit <= start) {
	throw new IllegalArgumentException("0 or negative length in GraphicComponent");
	}
	this.graphic = graphic;
	this.graphicAdvance = graphic.getAdvance();
	this.decorator = decorator;
	this.cm = createCoreMetrics(graphic);
	this.baseTx = baseTx;

	initLocalOrdering(charsLtoV, levels, start, limit);
	}

	private GraphicComponent(GraphicComponent parent, int start, int limit, int dir) {

	this.graphic = parent.graphic;
	this.graphicAdvance = parent.graphicAdvance;
	this.decorator = parent.decorator;
	this.cm = parent.cm;
	this.baseTx = parent.baseTx;

	int[] charsLtoV = null;
	byte[] levels = null;

	if (dir == UNCHANGED) {
	charsLtoV = parent.charsLtoV;
	levels = parent.levels;
	}
	else if (dir == LEFT_TO_RIGHT \|\| dir == RIGHT_TO_LEFT) {
	limit -= start;
	start = 0;
	if (dir == RIGHT_TO_LEFT) {
	charsLtoV = new int[limit];
	levels = new byte[limit];
	for (int i=0; i < limit; i++) {
	charsLtoV[i] = limit-i-1;
	levels[i] = (byte) 1;
	}
	}
	}
	else {
	throw new IllegalArgumentException("Invalid direction flag");
	}

	initLocalOrdering(charsLtoV, levels, start, limit);
	}

	/**
	* Initialize graphicCount, also charsLtoV and levels arrays.
	*/
	private void initLocalOrdering(int[] charsLtoV,
	byte[] levels,
	int start,
	int limit) {

	this.graphicCount = limit - start; // todo: should be codepoints?

	if (charsLtoV == null \|\| charsLtoV.length == graphicCount) {
	this.charsLtoV = charsLtoV;
	}
	else {
	this.charsLtoV = BidiUtils.createNormalizedMap(charsLtoV, levels, start, limit);
	}

	if (levels == null \|\| levels.length == graphicCount) {
	this.levels = levels;
	}
	else {
	this.levels = new byte[graphicCount];
	System.arraycopy(levels, start, this.levels, 0, graphicCount);
	}
	}

	public boolean isSimple() {
	return false;
	}

	public Rectangle getPixelBounds(FontRenderContext frc, float x, float y) {
	throw new InternalError("do not call if isSimple returns false");
	}

	public Rectangle2D handleGetVisualBounds() {

	Rectangle2D bounds = graphic.getBounds();

	float width = (float) bounds.getWidth() +
	graphicAdvance * (graphicCount-1);

	return new Rectangle2D.Float((float) bounds.getX(),
	(float) bounds.getY(),
	width,
	(float) bounds.getHeight());
	}

	public CoreMetrics getCoreMetrics() {
	return cm;
	}

	public static CoreMetrics createCoreMetrics(GraphicAttribute graphic) {
	return new CoreMetrics(graphic.getAscent(),
	graphic.getDescent(),
	GRAPHIC_LEADING,
	graphic.getAscent() + graphic.getDescent() + GRAPHIC_LEADING,
	graphic.getAlignment(),
	new float[] { 0, -graphic.getAscent() / 2, -graphic.getAscent() },
	-graphic.getAscent() / 2,
	graphic.getAscent() / 12,
	graphic.getDescent() / 3,
	graphic.getAscent() / 12,
	0, // ss offset
	0); // italic angle -- need api for this
	}

	public float getItalicAngle() {

	return 0;
	}

	public Rectangle2D getVisualBounds() {

	if (visualBounds == null) {
	visualBounds = decorator.getVisualBounds(this);
	}
	Rectangle2D.Float bounds = new Rectangle2D.Float();
	bounds.setRect(visualBounds);
	return bounds;
	}

	public Shape handleGetOutline(float x, float y) {
	double[] matrix = { 1, 0, 0, 1, x, y };

	if (graphicCount == 1) {
	AffineTransform tx = new AffineTransform(matrix);
	return graphic.getOutline(tx);
	}

	GeneralPath gp = new GeneralPath();
	for (int i = 0; i < graphicCount; ++i) {
	AffineTransform tx = new AffineTransform(matrix);
	gp.append(graphic.getOutline(tx), false);
	matrix[4] += graphicAdvance;
	}

	return gp;
	}

	public AffineTransform getBaselineTransform() {
	return baseTx;
	}

	public Shape getOutline(float x, float y) {

	return decorator.getOutline(this, x, y);
	}

	public void handleDraw(Graphics2D g2d, float x, float y) {

	for (int i=0; i < graphicCount; i++) {

	graphic.draw(g2d, x, y);
	x += graphicAdvance;
	}
	}

	public void draw(Graphics2D g2d, float x, float y) {

	decorator.drawTextAndDecorations(this, g2d, x, y);
	}

	public Rectangle2D getCharVisualBounds(int index) {

	return decorator.getCharVisualBounds(this, index);
	}

	public int getNumCharacters() {

	return graphicCount;
	}

	public float getCharX(int index) {

	int visIndex = charsLtoV==null? index : charsLtoV[index];
	return graphicAdvance * visIndex;
	}

	public float getCharY(int index) {

	return 0;
	}

	public float getCharAdvance(int index) {

	return graphicAdvance;
	}

	public boolean caretAtOffsetIsValid(int index) {

	return true;
	}

	public Rectangle2D handleGetCharVisualBounds(int index) {

	Rectangle2D bounds = graphic.getBounds();
	// don't modify their rectangle, just in case they don't copy

	Rectangle2D.Float charBounds = new Rectangle2D.Float();
	charBounds.setRect(bounds);
	charBounds.x += graphicAdvance * index;

	return charBounds;
	}

	// measures characters in context, in logical order
	public int getLineBreakIndex(int start, float width) {

	int index = (int) (width / graphicAdvance);
	if (index > graphicCount - start) {
	index = graphicCount - start;
	}
	return index;
	}

	// measures characters in context, in logical order
	public float getAdvanceBetween(int start, int limit) {

	return graphicAdvance * (limit - start);
	}

	public Rectangle2D getLogicalBounds() {

	float left = 0;
	float top = -cm.ascent;
	float width = graphicAdvance * graphicCount;
	float height = cm.descent - top;

	return new Rectangle2D.Float(left, top, width, height);
	}

	public float getAdvance() {
	return graphicAdvance * graphicCount;
	}

	public Rectangle2D getItalicBounds() {
	return getLogicalBounds();
	}

	public TextLineComponent getSubset(int start, int limit, int dir) {

	if (start < 0 \|\| limit > graphicCount \|\| start >= limit) {
	throw new IllegalArgumentException("Invalid range. start="
	+start+"; limit="+limit);
	}

	if (start == 0 && limit == graphicCount && dir == UNCHANGED) {
	return this;
	}

	return new GraphicComponent(this, start, limit, dir);
	}

	public String toString() {

	return "[graphic=" + graphic + ":count=" + getNumCharacters() + "]";
	}

	/**
	* Return the number of justification records this uses.
	*/
	public int getNumJustificationInfos() {
	return 0;
	}

	/**
	* Return GlyphJustificationInfo objects for the characters between
	* charStart and charLimit, starting at offset infoStart. Infos
	* will be in visual order. All positions between infoStart and
	* getNumJustificationInfos will be set. If a position corresponds
	* to a character outside the provided range, it is set to null.
	*/
	public void getJustificationInfos(GlyphJustificationInfo[] infos, int infoStart, int charStart, int charLimit) {
	}

	/**
	* Apply deltas to the data in this component, starting at offset
	* deltaStart, and return the new component. There are two floats
	* for each justification info, for a total of 2 * getNumJustificationInfos.
	* The first delta is the left adjustment, the second is the right
	* adjustment.
	* <p>
	* If flags[0] is true on entry, rejustification is allowed. If
	* the new component requires rejustification (ligatures were
	* formed or split), flags[0] will be set on exit.
	*/
	public TextLineComponent applyJustificationDeltas(float[] deltas, int deltaStart, boolean[] flags) {
	return this;
	}
	}

Back to index...