FOPGVTFont.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.
 */

/* $Id$ */

package org.apache.fop.svg.font;

import java.awt.font.FontRenderContext;
import java.text.AttributedString;
import java.text.CharacterIterator;
import java.text.StringCharacterIterator;

import org.apache.batik.gvt.font.GVTFont;
import org.apache.batik.gvt.font.GVTFontFamily;
import org.apache.batik.gvt.font.GVTGlyphVector;
import org.apache.batik.gvt.font.GVTLineMetrics;
import org.apache.batik.gvt.text.GVTAttributedCharacterIterator;

import org.apache.fop.fonts.Font;
import org.apache.fop.fonts.FontInfo;
import org.apache.fop.fonts.FontMetrics;
import org.apache.fop.fonts.FontTriplet;

public class FOPGVTFont implements GVTFont {

    private final Font font;

    private final GVTFontFamily fontFamily;

    public FOPGVTFont(Font font, GVTFontFamily fontFamily) {
        this.font = font;
        this.fontFamily = fontFamily;
    }

    public Font getFont() {
        return font;
    }

    public boolean canDisplay(char c) {
        return font.hasChar(c);
    }

    public int canDisplayUpTo(char[] text, int start, int limit) {
        for (int i = start; i < limit; i++) {
            if (!canDisplay(text[i])) {
                return i;
            }
        }
        return -1;
    }


    public int canDisplayUpTo(CharacterIterator iter, int start, int limit) {
        for (char c = iter.setIndex(start); iter.getIndex() < limit; c = iter.next()) {
            if (!canDisplay(c)) {
                return iter.getIndex();
            }
        }
        return -1;
    }

    public int canDisplayUpTo(String str) {
        for (int i = 0; i < str.length(); i++) {
            if (!canDisplay(str.charAt(i))) {
                return i;
            }
        }
        return -1;
    }

    public GVTGlyphVector createGlyphVector(FontRenderContext frc, char[] chars) {
        return createGlyphVector(frc, new String(chars));
    }

    public GVTGlyphVector createGlyphVector(FontRenderContext frc, CharacterIterator ci) {
        if (!font.performsSubstitution() && !font.performsPositioning()) {
            return new FOPGVTGlyphVector(this, ci, frc);
        } else {
            return new ComplexGlyphVector(this, ci, frc);
        }
    }

    public GVTGlyphVector createGlyphVector(FontRenderContext frc,
            int[] glyphCodes,
            CharacterIterator ci) {
        throw new UnsupportedOperationException("Not implemented");
    }

    public GVTGlyphVector createGlyphVector(FontRenderContext frc, String text) {
        StringCharacterIterator sci = new StringCharacterIterator(text);
        return createGlyphVector(frc, sci);
    }

    public GVTGlyphVector createGlyphVector(FontRenderContext frc, String text, String script, String language) {
        if ((script != null) || (language != null)) {
            AttributedString as = new AttributedString(text);
            if (script != null) {
                as.addAttribute(GVTAttributedCharacterIterator.TextAttribute.SCRIPT, script);
            }
            if (language != null) {
                as.addAttribute(GVTAttributedCharacterIterator.TextAttribute.LANGUAGE, language);
            }
            return createGlyphVector(frc, as.getIterator());
        } else {
            return createGlyphVector(frc, text);
        }
    }

    public FOPGVTFont deriveFont(float size) {
        throw new UnsupportedOperationException("Not implemented");
    }

    public FontInfo getFontInfo() {
        return ((FOPGVTFontFamily) fontFamily).getFontInfo();
    }

    public String getFontKey() {
        return font.getFontName();
    }

    public FontTriplet getFontTriplet() {
        return font.getFontTriplet();
    }

    public String getFamilyName() {
        return fontFamily.getFamilyName();
    }

    public GVTLineMetrics getLineMetrics(char[] chars, int beginIndex, int limit, FontRenderContext frc) {
        return getLineMetrics(limit - beginIndex);
    }

    GVTLineMetrics getLineMetrics(int numChars) {
        numChars = numChars < 0 ? 0 : numChars;
        FontMetrics metrics = font.getFontMetrics();
        int size = font.getFontSize();
        return new GVTLineMetrics(
                metrics.getCapHeight(size) / 1000000f,
                java.awt.Font.ROMAN_BASELINE, // Not actually used by Batik
                null, // Not actually used by Batik
                -metrics.getDescender(size) / 1000000f,
                0, // Not actually used by Batik
                0, // Not actually used by Batik
                numChars,
                -metrics.getStrikeoutPosition(size) / 1000000f,
                metrics.getStrikeoutThickness(size) / 1000000f,
                -metrics.getUnderlinePosition(size) / 1000000f,
                metrics.getUnderlineThickness(size) / 1000000f,
                -metrics.getCapHeight(size) / 1000000f, // Because this is what Batik does in GVTLineMetrics
                metrics.getUnderlineThickness(size) / 1000000f);
    }

    public GVTLineMetrics getLineMetrics(CharacterIterator ci, int beginIndex, int limit,
            FontRenderContext frc) {
        return getLineMetrics(limit - beginIndex);
    }

    public GVTLineMetrics getLineMetrics(String str, FontRenderContext frc) {
        return getLineMetrics(str.length());
    }

    public GVTLineMetrics getLineMetrics(String str, int beginIndex, int limit, FontRenderContext frc) {
        return getLineMetrics(limit - beginIndex);
    }

    public float getSize() {
        return font.getFontSize() / 1000f;
    }

    public float getVKern(int glyphCode1, int glyphCode2) {
        return 0;
    }

    public float getHKern(int glyphCode1, int glyphCode2) {
        // TODO Cannot be implemented until getKernValue takes glyph indices instead of character codes
        return 0;
    }

}