Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /* NOTICE: This file has been changed by Plutext Pty Ltd for use in docx4j.
   * The package name has been changed; there may also be other changes.
   * 
   * This notice is included to meet the condition in clause 4(b) of the License. 
   */
  
   /*
   * 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: Font.java 721430 2008-11-28 11:13:12Z acumiskey $ */
 
 package org.docx4j.fonts.fop.fonts;
 
 import java.util.Map;
 
This class holds font state information and provides access to the font metrics.
 
 public class Font {

    
Extra Bold font weight
 
     public static final int WEIGHT_EXTRA_BOLD = 800;

    
Bold font weight
 
     public static final int WEIGHT_BOLD = 700;

    
Normal font weight
 
     public static final int WEIGHT_NORMAL = 400;

    
Light font weight
 
     public static final int WEIGHT_LIGHT = 200;

    
Normal font style
 
     public static final String STYLE_NORMAL = "normal";

    
Italic font style
 
     public static final String STYLE_ITALIC = "italic";

    
Oblique font style
 
     public static final String STYLE_OBLIQUE = "oblique";

    
Inclined font style
 
     public static final String STYLE_INCLINED = "inclined";

    
Default selection priority
 
     public static final int PRIORITY_DEFAULT = 0;

    
Default fallback key
 
     public static final FontTriplet DEFAULT_FONT = new FontTriplet(
                     "any");

    
logger
 
     private  static Logger log = LoggerFactory.getLogger(Font.class);
 
     private final String fontName;
     private final FontTriplet triplet;
     private final int fontSize;

    
normal or small-caps font
 
     //private int fontVariant;
 
     private final FontMetrics metric;

    
Main constructor

Parameters:
key key of the font
triplet the font triplet that was used to lookup this font (may be null)
met font metrics
fontSize font size
 
     public Font(String keyFontTriplet tripletFontMetrics metint fontSize) {
         this. = key;
         this. = triplet;
         this. = met;
         this. = fontSize;
     }

    
Returns the associated font metrics object.

Returns:
the font metrics
    public FontMetrics getFontMetrics() {
        return this.;
    }

    
Returns the font's ascender.

Returns:
the ascender
    public int getAscender() {
        return .getAscender() / 1000;
    }

    
Returns the font's CapHeight.

Returns:
the capital height
    public int getCapHeight() {
        return .getCapHeight() / 1000;
    }

    
Returns the font's Descender.

Returns:
the descender
    public int getDescender() {
        return .getDescender() / 1000;
    }

    
Returns the font's name.

Returns:
the font name
    public String getFontName() {
        return ;
    }

    

Returns:
the font triplet that selected this font
    public FontTriplet getFontTriplet() {
        return this.;
    }

    
Returns the font size

Returns:
the font size
    public int getFontSize() {
        return ;
    }

    
Returns the XHeight

Returns:
the XHeight
    public int getXHeight() {
        return .getXHeight() / 1000;
    }

    

Returns:
true if the font has kerning info
    public boolean hasKerning() {
        return .hasKerningInfo();
    }

    
Returns the font's kerning table

Returns:
the kerning table
    public Map getKerning() {
        if (.hasKerningInfo()) {
            return .getKerningInfo();
        } else {
            return ...;
        }
    }

    
Returns the amount of kerning between two characters.

Parameters:
ch1 first character
ch2 second character
Returns:
the distance to adjust for kerning, 0 if there's no kerning
    public int getKernValue(char ch1char ch2) {
        Map kernPair = (Map)getKerning().get(new Integer(ch1));
        if (kernPair != null) {
            Integer width = (Integer)kernPair.get(new Integer(ch2));
            if (width != null) {
                return width.intValue();
            }
        }
        return 0;
    }

    
Returns the width of a character

Parameters:
charnum character to look up
Returns:
width of the character
    public int getWidth(int charnum) {
        // returns width of given character number in millipoints
        return (.getWidth(charnum) / 1000);
    }

    
Map a java character (unicode) to a font character. Default uses CodePointMapping.

Parameters:
c character to map
Returns:
the mapped character
    public char mapChar(char c) {
        if ( instanceof org.docx4j.fonts.fop.fonts.Typeface) {
            return ((org.docx4j.fonts.fop.fonts.Typeface)).mapChar(c);
        }
        // Use default CodePointMapping
        char d = CodePointMapping.getMapping("WinAnsiEncoding").mapChar(c);
        if (d != .) {
            c = d;
        } else {
            .warn("Glyph " + (intc + " not available in font " + );
            c = .;
        }
        return c;
    }

    
Determines whether this font contains a particular character/glyph.

Parameters:
c character to check
Returns:
True if the character is supported, Falso otherwise
    public boolean hasChar(char c) {
        if ( instanceof org.docx4j.fonts.fop.fonts.Typeface) {
            return ((org.docx4j.fonts.fop.fonts.Typeface)).hasChar(c);
        } else {
            // Use default CodePointMapping
            return (CodePointMapping.getMapping("WinAnsiEncoding").mapChar(c) > 0);
        }
    }

    
    public String toString() {
        StringBuffer sbuf = new StringBuffer();
        sbuf.append('(');
        /*
        sbuf.append(fontFamily);
        sbuf.append(',');*/
        sbuf.append();
        sbuf.append(',');
        sbuf.append();
        /*
        sbuf.append(',');
        sbuf.append(fontStyle);
        sbuf.append(',');
        sbuf.append(fontWeight);*/
        sbuf.append(')');
        return sbuf.toString();
    }

    
Helper method for getting the width of a unicode char from the current fontstate. This also performs some guessing on widths on various versions of space that might not exists in the font.

Parameters:
c character to inspect
Returns:
the width of the character
    public int getCharWidth(char c) {
        int width;
        if ((c == '\n') || (c == '\r') || (c == '\t') || (c == '\u00A0')) {
            width = getCharWidth(' ');
        } else {
            if (hasChar(c)) {
                int mappedChar = mapChar(c);
                width = getWidth(mappedChar);
            } else {
                width = -1;
            }
            if (width <= 0) {
                // Estimate the width of spaces not represented in
                // the font
                int em = getFontSize(); //http://en.wikipedia.org/wiki/Em_(typography)
                int en = em / 2; //http://en.wikipedia.org/wiki/En_(typography)
                if (c == ' ') {
                    width = em;
                } else if (c == '\u2000') {
                    width = en;
                } else if (c == '\u2001') {
                    width = em;
                } else if (c == '\u2002') {
                    width = em / 2;
                } else if (c == '\u2003') {
                    width = getFontSize();
                } else if (c == '\u2004') {
                    width = em / 3;
                } else if (c == '\u2005') {
                    width = em / 4;
                } else if (c == '\u2006') {
                    width = em / 6;
                } else if (c == '\u2007') {
                    width = getCharWidth('0');
                } else if (c == '\u2008') {
                    width = getCharWidth('.');
                } else if (c == '\u2009') {
                    width = em / 5;
                } else if (c == '\u200A') {
                    width = em / 10;
                } else if (c == '\u200B') {
                    width = 0;
                } else if (c == '\u202F') {
                    width = getCharWidth(' ') / 2;
                } else if (c == '\u2060') {
                    width = 0;
                } else if (c == '\u3000') {
                    width = getCharWidth(' ') * 2;
                } else if (c == '\ufeff') {
                    width = 0;
                } else {
                    //Will be internally replaced by "#" if not found
                    width = getWidth(mapChar(c));
                }
            }
        }
        return width;
    }

    
Calculates the word width.

Parameters:
word text to get width for
Returns:
the width of the text
    public int getWordWidth(String word) {
        if (word == null) {
            return 0;
        }
        int wordLength = word.length();
        int width = 0;
        char[] characters = new char[wordLength];
        word.getChars(0, wordLengthcharacters, 0);
        for (int i = 0; i < wordLengthi++) {
            width += getCharWidth(characters[i]);
        }
        return width;
    }
New to GrepCode? Check out our FAQ X