267 lines
7.1 KiB
Java
267 lines
7.1 KiB
Java
/*
|
|
* Licensed to the Apache Software Foundation (ASF) under one or more
|
|
* contributor license agreements. See the NOTICE file distributed with
|
|
* this work for additional information regarding copyright ownership.
|
|
* The ASF licenses this file to You under the Apache License, Version 2.0
|
|
* (the "License"); you may not use this file except in compliance with
|
|
* the License. You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
/**
|
|
* @author Ilya S. Okomin
|
|
* @version $Revision$
|
|
*/
|
|
|
|
package java.awt.font;
|
|
|
|
import java.awt.geom.Rectangle2D;
|
|
|
|
/**
|
|
* The GlyphMetrics class provides information about the size and shape of a
|
|
* single glyph. Each glyph has information to specify whether its baseline is
|
|
* horizontal or vertical as well as information on how it interacts with other
|
|
* characters in a text, given as one of the following types: STANDARD,
|
|
* LIGATURE, COMBINING, or COMPONENT.
|
|
*
|
|
* @since Android 1.0
|
|
*/
|
|
public final class GlyphMetrics {
|
|
|
|
// advance width of the glyph character cell
|
|
/**
|
|
* The advance x.
|
|
*/
|
|
private float advanceX;
|
|
|
|
// advance height of the glyph character cell
|
|
/**
|
|
* The advance y.
|
|
*/
|
|
private float advanceY;
|
|
|
|
// flag if the glyph horizontal
|
|
/**
|
|
* The horizontal.
|
|
*/
|
|
private boolean horizontal;
|
|
|
|
// glyph type code
|
|
/**
|
|
* The glyph type.
|
|
*/
|
|
private byte glyphType;
|
|
|
|
// bounding box for outline of the glyph
|
|
/**
|
|
* The bounds.
|
|
*/
|
|
private Rectangle2D.Float bounds;
|
|
|
|
/**
|
|
* The Constant STANDARD indicates a glyph that represents a single
|
|
* character.
|
|
*/
|
|
public static final byte STANDARD = 0;
|
|
|
|
/**
|
|
* The Constant LIGATURE indicates a glyph that represents multiple
|
|
* characters as a ligature.
|
|
*/
|
|
public static final byte LIGATURE = 1;
|
|
|
|
/**
|
|
* The Constant COMBINING indicates a glyph which has no caret position
|
|
* between glyphs (for example umlaut).
|
|
*/
|
|
public static final byte COMBINING = 2;
|
|
|
|
/**
|
|
* The Constant COMPONENT indicates a glyph with no corresponding character
|
|
* in the backing store.
|
|
*/
|
|
public static final byte COMPONENT = 3;
|
|
|
|
/**
|
|
* The Constant WHITESPACE indicates a glyph without visual representation.
|
|
*/
|
|
public static final byte WHITESPACE = 4;
|
|
|
|
/**
|
|
* Instantiates a new GlyphMetrics object with the specified parameters.
|
|
*
|
|
* @param horizontal
|
|
* specifies if metrics are for a horizontal baseline (true
|
|
* value), or a vertical baseline (false value).
|
|
* @param advanceX
|
|
* the X component of the glyph's advance.
|
|
* @param advanceY
|
|
* the Y component of the glyph's advance.
|
|
* @param bounds
|
|
* the glyph's bounds.
|
|
* @param glyphType
|
|
* the glyph's type.
|
|
*/
|
|
public GlyphMetrics(boolean horizontal, float advanceX, float advanceY, Rectangle2D bounds,
|
|
byte glyphType) {
|
|
this.horizontal = horizontal;
|
|
this.advanceX = advanceX;
|
|
this.advanceY = advanceY;
|
|
|
|
this.bounds = new Rectangle2D.Float();
|
|
this.bounds.setRect(bounds);
|
|
|
|
this.glyphType = glyphType;
|
|
}
|
|
|
|
/**
|
|
* Instantiates a new horizontal GlyphMetrics with the specified parameters.
|
|
*
|
|
* @param advanceX
|
|
* the X component of the glyph's advance.
|
|
* @param bounds
|
|
* the glyph's bounds.
|
|
* @param glyphType
|
|
* the glyph's type.
|
|
*/
|
|
public GlyphMetrics(float advanceX, Rectangle2D bounds, byte glyphType) {
|
|
this.advanceX = advanceX;
|
|
this.advanceY = 0;
|
|
|
|
this.horizontal = true;
|
|
|
|
this.bounds = new Rectangle2D.Float();
|
|
this.bounds.setRect(bounds);
|
|
|
|
this.glyphType = glyphType;
|
|
}
|
|
|
|
/**
|
|
* Gets the glyph's bounds.
|
|
*
|
|
* @return glyph's bounds.
|
|
*/
|
|
public Rectangle2D getBounds2D() {
|
|
return (Rectangle2D.Float)this.bounds.clone();
|
|
}
|
|
|
|
/**
|
|
* Checks if this glyph is whitespace or not.
|
|
*
|
|
* @return true, if this glyph is whitespace, false otherwise.
|
|
*/
|
|
public boolean isWhitespace() {
|
|
return ((this.glyphType & 4) == WHITESPACE);
|
|
}
|
|
|
|
/**
|
|
* Checks if this glyph is standard or not.
|
|
*
|
|
* @return true, if this glyph is standard, false otherwise.
|
|
*/
|
|
public boolean isStandard() {
|
|
return ((this.glyphType & 3) == STANDARD);
|
|
}
|
|
|
|
/**
|
|
* Checks if this glyph is ligature or not.
|
|
*
|
|
* @return true, if this glyph is ligature, false otherwise.
|
|
*/
|
|
public boolean isLigature() {
|
|
return ((this.glyphType & 3) == LIGATURE);
|
|
}
|
|
|
|
/**
|
|
* Checks if this glyph is component or not.
|
|
*
|
|
* @return true, if this glyph is component, false otherwise.
|
|
*/
|
|
public boolean isComponent() {
|
|
return ((this.glyphType & 3) == COMPONENT);
|
|
}
|
|
|
|
/**
|
|
* Checks if this glyph is combining or not.
|
|
*
|
|
* @return true, if this glyph is combining, false otherwise.
|
|
*/
|
|
public boolean isCombining() {
|
|
return ((this.glyphType & 3) == COMBINING);
|
|
}
|
|
|
|
/**
|
|
* Gets the glyph's type.
|
|
*
|
|
* @return the glyph's type.
|
|
*/
|
|
public int getType() {
|
|
return this.glyphType;
|
|
}
|
|
|
|
/**
|
|
* Gets the distance from the right (for horizontal) or bottom (for
|
|
* vertical) of the glyph bounds to the advance.
|
|
*
|
|
* @return the distance from the right (for horizontal) or bottom (for
|
|
* vertical) of the glyph bounds to the advance.
|
|
*/
|
|
public float getRSB() {
|
|
if (this.horizontal) {
|
|
return this.advanceX - this.bounds.x - (float)this.bounds.getWidth();
|
|
}
|
|
return this.advanceY - this.bounds.y - (float)this.bounds.getHeight();
|
|
}
|
|
|
|
/**
|
|
* Gets the distance from 0, 0 to the left (for horizontal) or top (for
|
|
* vertical) of the glyph bounds.
|
|
*
|
|
* @return the distance from 0, 0 to the left (for horizontal) or top (for
|
|
* vertical) of the glyph bounds.
|
|
*/
|
|
public float getLSB() {
|
|
if (this.horizontal) {
|
|
return this.bounds.x;
|
|
}
|
|
return this.bounds.y;
|
|
}
|
|
|
|
/**
|
|
* Gets the Y component of the glyph's advance.
|
|
*
|
|
* @return the Y component of the glyph's advance.
|
|
*/
|
|
public float getAdvanceY() {
|
|
return this.advanceY;
|
|
}
|
|
|
|
/**
|
|
* Gets the X component of the glyph's advance.
|
|
*
|
|
* @return the X component of the glyph's advance.
|
|
*/
|
|
public float getAdvanceX() {
|
|
return this.advanceX;
|
|
}
|
|
|
|
/**
|
|
* Gets the glyph's advance along the baseline.
|
|
*
|
|
* @return the glyph's advance.
|
|
*/
|
|
public float getAdvance() {
|
|
if (this.horizontal) {
|
|
return this.advanceX;
|
|
}
|
|
return this.advanceY;
|
|
}
|
|
|
|
}
|