org.docx4j.fonts.fop.fonts.CustomFont Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of docx4j Show documentation
Show all versions of docx4j Show documentation
docx4j is a library which helps you to work with the Office Open
XML file format as used in docx
documents, pptx presentations, and xlsx spreadsheets.
The newest version!
/* 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: CustomFont.java 721430 2008-11-28 11:13:12Z acumiskey $ */
/* NOTICE: This file has been changed by Plutext Pty Ltd for use in docx4j.
*
* This notice is included to meet the condition in clause 4(b) of the License.
*/
package org.docx4j.fonts.fop.fonts;
import java.io.IOException;
import java.util.Collections;
import java.util.Map;
import java.util.Set;
import javax.xml.transform.Source;
import org.docx4j.fonts.foray.font.format.Panose;
/**
* Abstract base class for custom fonts loaded from files, for example.
*/
public abstract class CustomFont extends Typeface
implements FontDescriptor, MutableFont {
private String fontName = null;
private String fullName = null;
private Set familyNames = null; //Set
private String fontSubName = null;
private String embedFileName = null;
private String embedResourceName = null;
private FontResolver resolver = null;
private int capHeight = 0;
private int xHeight = 0;
private int ascender = 0;
private int descender = 0;
private int[] fontBBox = {0, 0, 0, 0};
private int flags = 4;
private int weight = 0; //0 means unknown weight
private int stemV = 0;
private int italicAngle = 0;
private int missingWidth = 0;
private FontType fontType = FontType.TYPE1;
private int firstChar = 0;
private int lastChar = 255;
private Map kerning;
private boolean useKerning = true;
private boolean isEmbeddable = true;
public boolean isEmbeddable() {
return isEmbeddable;
}
public void setEmbeddable(boolean isEmbeddable) {
this.isEmbeddable = isEmbeddable;
}
private Panose panose = null;
public Panose getPanose() {
return panose;
}
public void setPanose(Panose panose) {
this.panose = panose;
}
/** {@inheritDoc} */
public String getFontName() {
return fontName;
}
/** {@inheritDoc} */
public String getEmbedFontName() {
return getFontName();
}
/** {@inheritDoc} */
public String getFullName() {
return fullName;
}
/**
* Returns the font family names.
* @return the font family names (a Set of Strings)
*/
public Set getFamilyNames() {
return Collections.unmodifiableSet(this.familyNames);
}
/**
* Returns the font family name stripped of whitespace.
* @return the stripped font family
* @see FontUtil#stripWhiteSpace(String)
*/
public String getStrippedFontName() {
return FontUtil.stripWhiteSpace(getFontName());
}
/**
* Returns font's subfamily name.
* @return the font's subfamily name
*/
public String getFontSubName() {
return fontSubName;
}
/**
* Returns an URI representing an embeddable font file. The URI will often
* be a filename or an URL.
* @return URI to an embeddable font file or null if not available.
*/
public String getEmbedFileName() {
return embedFileName;
}
/**
* Returns a Source representing an embeddable font file.
* @return Source for an embeddable font file
* @throws IOException if embedFileName is not null but Source is not found
*/
public Source getEmbedFileSource() throws IOException {
Source result = null;
if (resolver != null && embedFileName != null) {
result = resolver.resolve(embedFileName);
if (result == null) {
throw new IOException("Unable to resolve Source '"
+ embedFileName + "' for embedded font");
}
}
return result;
}
/**
* Returns the lookup name to an embeddable font file available as a
* resource.
* (todo) Remove this method, this should be done using a resource: URI.
* @return the lookup name
*/
public String getEmbedResourceName() {
return embedResourceName;
}
/**
* {@inheritDoc}
*/
public int getAscender() {
return ascender;
}
/**
* {@inheritDoc}
*/
public int getDescender() {
return descender;
}
/**
* {@inheritDoc}
*/
public int getCapHeight() {
return capHeight;
}
/**
* {@inheritDoc}
*/
public int getAscender(int size) {
return size * ascender;
}
/**
* {@inheritDoc}
*/
public int getDescender(int size) {
return size * descender;
}
/**
* {@inheritDoc}
*/
public int getCapHeight(int size) {
return size * capHeight;
}
/**
* {@inheritDoc}
*/
public int getXHeight(int size) {
return size * xHeight;
}
/**
* {@inheritDoc}
*/
public int[] getFontBBox() {
return fontBBox;
}
/** {@inheritDoc} */
public int getFlags() {
return flags;
}
/** {@inheritDoc} */
public boolean isSymbolicFont() {
return ((getFlags() & 4) != 0) || "ZapfDingbatsEncoding".equals(getEncodingName());
//Note: The check for ZapfDingbats is necessary as the PFM does not reliably indicate
//if a font is symbolic.
}
/**
* Returns the font weight (100, 200...800, 900). This value may be different from the
* one that was actually used to register the font.
* @return the font weight (or 0 if the font weight is unknown)
*/
public int getWeight() {
return this.weight;
}
/**
* {@inheritDoc}
*/
public int getStemV() {
return stemV;
}
/**
* {@inheritDoc}
*/
public int getItalicAngle() {
return italicAngle;
}
/**
* Returns the width to be used when no width is available.
* @return a character width
*/
public int getMissingWidth() {
return missingWidth;
}
/**
* {@inheritDoc}
*/
public FontType getFontType() {
return fontType;
}
/**
* Returns the index of the first character defined in this font.
* @return the index of the first character
*/
public int getFirstChar() {
return firstChar;
}
/**
* Returns the index of the last character defined in this font.
* @return the index of the last character
*/
public int getLastChar() {
return lastChar;
}
/**
* Used to determine if kerning is enabled.
* @return True if kerning is enabled.
*/
public boolean isKerningEnabled() {
return useKerning;
}
/**
* {@inheritDoc}
*/
public final boolean hasKerningInfo() {
return (isKerningEnabled() && (kerning != null) && !kerning.isEmpty());
}
/**
* {@inheritDoc}
*/
public final Map getKerningInfo() {
if (hasKerningInfo()) {
return kerning;
} else {
return java.util.Collections.EMPTY_MAP;
}
}
/* ---- MutableFont interface ---- */
/** {@inheritDoc} */
public void setFontName(String name) {
this.fontName = name;
}
/** {@inheritDoc} */
public void setFullName(String name) {
this.fullName = name;
}
/** {@inheritDoc} */
public void setFamilyNames(Set names) {
this.familyNames = new java.util.HashSet(names);
}
/**
* Sets the font's subfamily name.
* @param subFamilyName the subfamily name of the font
*/
public void setFontSubFamilyName(String subFamilyName) {
this.fontSubName = subFamilyName;
}
/**
* {@inheritDoc}
*/
public void setEmbedFileName(String path) {
this.embedFileName = path;
}
/**
* {@inheritDoc}
*/
public void setEmbedResourceName(String name) {
this.embedResourceName = name;
}
/**
* {@inheritDoc}
*/
public void setCapHeight(int capHeight) {
this.capHeight = capHeight;
}
/**
* Returns the XHeight value of the font.
* @param xHeight the XHeight value
*/
public void setXHeight(int xHeight) {
this.xHeight = xHeight;
}
/**
* {@inheritDoc}
*/
public void setAscender(int ascender) {
this.ascender = ascender;
}
/**
* {@inheritDoc}
*/
public void setDescender(int descender) {
this.descender = descender;
}
/**
* {@inheritDoc}
*/
public void setFontBBox(int[] bbox) {
this.fontBBox = bbox;
}
/**
* {@inheritDoc}
*/
public void setFlags(int flags) {
this.flags = flags;
}
/**
* Sets the font weight. Valid values are 100, 200...800, 900.
* @param weight the font weight
*/
public void setWeight(int weight) {
weight = (weight / 100) * 100;
weight = Math.max(100, weight);
weight = Math.min(900, weight);
this.weight = weight;
}
/**
* {@inheritDoc}
*/
public void setStemV(int stemV) {
this.stemV = stemV;
}
/**
* {@inheritDoc}
*/
public void setItalicAngle(int italicAngle) {
this.italicAngle = italicAngle;
}
/**
* {@inheritDoc}
*/
public void setMissingWidth(int width) {
this.missingWidth = width;
}
/**
* {@inheritDoc}
*/
public void setFontType(FontType fontType) {
this.fontType = fontType;
}
/**
* {@inheritDoc}
*/
public void setFirstChar(int index) {
this.firstChar = index;
}
/**
* {@inheritDoc}
*/
public void setLastChar(int index) {
this.lastChar = index;
}
/**
* {@inheritDoc}
*/
public void setKerningEnabled(boolean enabled) {
this.useKerning = enabled;
}
/**
* Sets the font resolver. Needed for URI resolution.
* @param resolver the font resolver
*/
public void setResolver(FontResolver resolver) {
this.resolver = resolver;
}
/** {@inheritDoc} */
public void putKerningEntry(Integer key, Map value) {
if (kerning == null) {
kerning = new java.util.HashMap();
}
this.kerning.put(key, value);
}
/**
* Replaces the existing kerning map with a new one.
* @param kerningMap the kerning map (Map, the integers are
* character codes)
*/
public void replaceKerningMap(Map kerningMap) {
if (kerningMap == null) {
this.kerning = Collections.EMPTY_MAP;
} else {
this.kerning = kerningMap;
}
}
}