/*
* 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
*/
package org.apache.harmony.awt.gl.font;
import org.apache.harmony.awt.gl.font.FontPeerImpl;
import org.apache.harmony.awt.gl.font.FontProperty;
import com.jgraph.gaeawt.java.awt.font.FontRenderContext;
import com.jgraph.gaeawt.java.awt.font.LineMetrics;
import com.jgraph.gaeawt.java.awt.geom.AffineTransform;
import com.jgraph.gaeawt.java.awt.geom.Rectangle2D;
/**
* CompositeFont class is the implementation of logical font classes.
* Every logical font consists of several physical fonts that described
* in font.properties file according to the face name of this logical font.
*/
public class CompositeFont extends FontPeerImpl{
// a number of physical fonts that CompositeFont consist of
int numFonts;
// font family name
String family;
// font face name
String face;
String[] fontNames;
// an array of font properties applicable to this CompositeFont
FontProperty[] fontProperties;
// an array of font peers applicable to this CompositeFont
public FontPeerImpl[] fPhysicalFonts;
// missing glyph code field
int missingGlyphCode = -1;
// line metrics of this font
LineMetricsImpl nlm = null;
// cached num glyphs parameter of this font that is the sum of num glyphs of
// font peers composing this font
int cachedNumGlyphs = -1;
/**
* Creates CompositeFont object that is corresponding to the specified logical
* family name.
*
* @param familyName logical family name CompositeFont is to be created from
* @param faceName logical face name CompositeFont is to be created from
* @param _style style of the CompositeFont to be created
* @param _size size of the CompositeFont to be created
* @param fProperties an array of FontProperties describing physical fonts -
* parts of logical font
* @param physFonts an array of physical font peers related to the CompositeFont
* to be created
*/
public CompositeFont(String familyName, String faceName, int _style, int _size, FontProperty[] fProperties, FontPeerImpl[] physFonts){
this.size = _size;
this.name = faceName;
this.family = familyName;
this.style = _style;
this.face = faceName;
this.psName = faceName;
this.fontProperties = fProperties;// !! Supposed that fProperties parameter != null
fPhysicalFonts = physFonts;
numFonts = fPhysicalFonts.length;
setDefaultLineMetrics("", null); //$NON-NLS-1$
this.uniformLM = false;
}
/**
* Returns the index of the FontPeer in array of physical fonts that is applicable
* for the given character. This font has to have the highest priority among fonts
* that can display this character and don't have exclusion range covering
* specified character. If there is no desired fonts -1 is returned.
*
* @param chr specified character
* @return index of the font from the array of physical fonts that will be used
* during processing of the specified character.
*/
public int getCharFontIndex(char chr){
for (int i = 0; i < numFonts; i++){
if (fontProperties[i].isCharExcluded(chr)){
continue;
}
if (fPhysicalFonts[i].canDisplay(chr)){
return i;
}
}
return -1;
}
/**
* Returns the index of the FontPeer in array of physical fonts that is applicable
* for the given character. This font has to have the highest priority among fonts
* that can display this character and don't have exclusion range covering
* specified character. If there is no desired fonts default value is returned.
*
* @param chr specified character
* @param defaultValue default index that is returned if the necessary font couldn't be found.
* @return index of the font from the array of physical fonts that will be used
* during processing of the specified character.
*/
public int getCharFontIndex(char chr, int defaultValue){
for (int i = 0; i < numFonts; i++){
if (fontProperties[i].isCharExcluded(chr)){
continue;
}
if (fPhysicalFonts[i].canDisplay(chr)){
return i;
}
}
return defaultValue;
}
/**
* Returns true if one of the physical fonts composing this font CompositeFont
* can display specified character.
*
* @param chr specified character
*/
@Override
public boolean canDisplay(char chr){
return (getCharFontIndex(chr) != -1);
}
/**
* Returns logical ascent (in pixels)
*/
@Override
public int getAscent(){
return nlm.getLogicalAscent();
}
/**
* Returns LineMetrics instance scaled according to the specified transform.
*
* @param str specified String
* @param frc specified FontRenderContext
* @param at specified AffineTransform
*/
@Override
public LineMetrics getLineMetrics(String str, FontRenderContext frc , AffineTransform at){
AffineTransform frcAt = null;
LineMetricsImpl lm = (LineMetricsImpl)(this.nlm.clone());
lm.setNumChars(str.length());
if (frc != null)
frcAt = frc.getTransform();
if ((at != null) && (!at.isIdentity())){
if (frcAt != null)
at.concatenate(frcAt);
lm.scale((float)at.getScaleX(), (float)at.getScaleY());
} else if ((frcAt != null) && (!frcAt.isIdentity())){
lm.scale((float)frcAt.getScaleX(), (float)frcAt.getScaleY());
}
return lm;
}
/**
* Returns cached LineMetrics instance for the null string or creates it if
* it wasn't cached yet.
*/
@Override
public LineMetrics getLineMetrics(){
if (nlm == null){
setDefaultLineMetrics("", null); //$NON-NLS-1$
}
return this.nlm;
}
/**
* Creates LineMetrics instance and set cached LineMetrics field to it.
* Created LineMetrics has maximum values of the idividual metrics of all
* composing physical fonts. If there is only one physical font - it's
* LineMetrics object is returned.
*
* @param str specified String
* @param frc specified FontRenderContext
*/
private void setDefaultLineMetrics(String str, FontRenderContext frc){
LineMetrics lm = fPhysicalFonts[0].getLineMetrics(str, frc, null);
float maxCharWidth = (float)fPhysicalFonts[0].getMaxCharBounds(frc).getWidth();
if (numFonts == 1) {
this.nlm = (LineMetricsImpl)lm;
return;
}
float[] baselineOffsets = lm.getBaselineOffsets();
int numChars = str.length();
// XXX: default value - common for all Fonts
int baseLineIndex = lm.getBaselineIndex();
float maxUnderlineThickness = lm.getUnderlineThickness();
float maxUnderlineOffset = lm.getUnderlineOffset();
float maxStrikethroughThickness = lm.getStrikethroughThickness();
float minStrikethroughOffset = lm.getStrikethroughOffset();
float maxLeading = lm.getLeading(); // External leading
float maxHeight = lm.getHeight(); // Height of the font ( == (ascent + descent + leading))
float maxAscent = lm.getAscent(); // Ascent of the font
float maxDescent = lm.getDescent(); // Descent of the font
for (int i = 1; i < numFonts; i++){
lm = fPhysicalFonts[i].getLineMetrics(str, frc, null);
if (maxUnderlineThickness < lm.getUnderlineThickness()){
maxUnderlineThickness = lm.getUnderlineThickness();
}
if (maxUnderlineOffset < lm.getUnderlineOffset()){
maxUnderlineOffset = lm.getUnderlineOffset();
}
if (maxStrikethroughThickness < lm.getStrikethroughThickness()){
maxStrikethroughThickness = lm.getStrikethroughThickness();
}
if (minStrikethroughOffset > lm.getStrikethroughOffset()){
minStrikethroughOffset = lm.getStrikethroughOffset();
}
if (maxLeading < lm.getLeading()){
maxLeading = lm.getLeading();
}
if (maxAscent < lm.getAscent()){
maxAscent = lm.getAscent();
}
if (maxDescent < lm.getDescent()){
maxDescent = lm.getDescent();
}
float width = (float)fPhysicalFonts[i].getMaxCharBounds(frc).getWidth();
if(maxCharWidth < width){
maxCharWidth = width;
}
for (int j =0; j < baselineOffsets.length; j++){
float[] offsets = lm.getBaselineOffsets();
if (baselineOffsets[j] > offsets[j]){
baselineOffsets[j] = offsets[j];
}
}
}
maxHeight = maxAscent + maxDescent + maxLeading;
this.nlm = new LineMetricsImpl(
numChars,
baseLineIndex,
baselineOffsets,
maxUnderlineThickness,
maxUnderlineOffset,
maxStrikethroughThickness,
minStrikethroughOffset,
maxLeading,
maxHeight,
maxAscent,
maxDescent,
maxCharWidth);
}
/**
* Returns the number of glyphs in this CompositeFont object.
*/
@Override
public int getNumGlyphs(){
if (this.cachedNumGlyphs == -1){
this.cachedNumGlyphs = 0;
for (int i = 0; i < numFonts; i++){
this.cachedNumGlyphs += fPhysicalFonts[i].getNumGlyphs();
}
}
return this.cachedNumGlyphs;
}
/**
* Returns the italic angle of this object.
*/
@Override
public float getItalicAngle(){
// !! only first physical font used to get this value
return fPhysicalFonts[0].getItalicAngle();
}
/**
* Returns rectangle that bounds the specified string in terms of composite line metrics.
*
* @param chars an array of chars
* @param start the initial offset in array of chars
* @param end the end offset in array of chars
* @param frc specified FontRenderContext
*/
public Rectangle2D getStringBounds(char[] chars, int start, int end, FontRenderContext frc){
if (nlm == null){
setDefaultLineMetrics("", frc); //$NON-NLS-1$
}
LineMetrics lm = nlm;
float minY = -lm.getAscent();
float minX = 0;
float height = lm.getHeight();
float width = 0;
for (int i = start; i < end; i++){
width += charWidth(chars[i]);
}
Rectangle2D rect2D = new Rectangle2D.Float(minX, minY, width, height);
return rect2D;
}
/**
* Returns maximum rectangle that encloses all maximum char bounds of
* physical fonts composing this CompositeFont.
*
* @param frc specified FontRenderContext
*/
@Override
public Rectangle2D getMaxCharBounds(FontRenderContext frc){
Rectangle2D rect2D = fPhysicalFonts[0].getMaxCharBounds(frc);
float minY = (float)rect2D.getY();
float maxWidth = (float)rect2D.getWidth();
float maxHeight = (float)rect2D.getHeight();
if (numFonts == 1){
return rect2D;
}
for (int i = 1; i < numFonts; i++){
if (fPhysicalFonts[i] != null){
rect2D = fPhysicalFonts[i].getMaxCharBounds(frc);
float y = (float)rect2D.getY();
float mWidth = (float)rect2D.getWidth();
float mHeight = (float)rect2D.getHeight();
if (y < minY){
minY = y;
}
if (mWidth > maxWidth){
maxHeight = mWidth;
}
if (mHeight > maxHeight){
maxHeight = mHeight;
}
}
}
rect2D = new Rectangle2D.Float(0, minY, maxWidth, maxHeight);
return rect2D;
}
/**
* Returns font name.
*/
@Override
public String getFontName(){
return face;
}
/**
* Returns font postscript name.
*/
@Override
public String getPSName(){
return psName;
}
/**
* Returns font family name.
*/
@Override
public String getFamily(){
return family;
}
/**
* Returns the code of the missing glyph.
*/
@Override
public int getMissingGlyphCode(){
// !! only first physical font used to get this value
return fPhysicalFonts[0].getMissingGlyphCode();
}
/**
* Returns Glyph object corresponding to the specified character.
*
* @param ch specified char
*/
@Override
public Glyph getGlyph(char ch){
for (int i = 0; i < numFonts; i++){
if (fontProperties[i].isCharExcluded(ch)){
continue;
}
/* Control symbols considered to be supported by the font peer */
if ((ch < 0x20) || fPhysicalFonts[i].canDisplay(ch)){
return fPhysicalFonts[i].getGlyph(ch);
}
}
return getDefaultGlyph();
}
/**
* Returns width of the char with specified index.
*
* @param ind specified index of the character
*/
@Override
public int charWidth(int ind){
return charWidth((char)ind);
}
/**
* Returns width of the specified char.
*
* @param c specified character
*/
@Override
public int charWidth(char c){
Glyph gl = this.getGlyph(c);
return (int)gl.getGlyphPointMetrics().getAdvanceX();
}
/**
* Returns debug information about this class.
*/
@Override
public String toString(){
return new String(this.getClass().getName() +
"[name=" + this.name + //$NON-NLS-1$
",style="+ this.style + //$NON-NLS-1$
",fps=" + this.fontProperties + "]"); //$NON-NLS-1$ //$NON-NLS-2$
}
/**
* Returns Glyph object corresponding to the default glyph.
*/
@Override
public Glyph getDefaultGlyph(){
// !! only first physical font used to get this value
return fPhysicalFonts[0].getDefaultGlyph();
}
/**
* Returns FontExtraMetrics object with extra metrics
* related to this CompositeFont.
*/
@Override
public FontExtraMetrics getExtraMetrics(){
// Returns FontExtraMetrics instance of the first physical
// Font from the array of fonts.
return fPhysicalFonts[0].getExtraMetrics();
}
/**
* Disposes CompositeFont object's resources.
*/
@Override
public void dispose() {
// Nothing to dispose
}
}