src/java/org/apache/fop/fonts/MultiByteFont.java - xmlgraphics-fop - Git at Google

 /*
  * 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.fonts;

 import java.nio.CharBuffer;
 import java.nio.IntBuffer;
 import java.util.BitSet;
 import java.util.Map;

 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;

 import org.apache.fop.apps.io.InternalResourceResolver;
 import org.apache.fop.complexscripts.fonts.GlyphDefinitionTable;
 import org.apache.fop.complexscripts.fonts.GlyphPositioningTable;
 import org.apache.fop.complexscripts.fonts.GlyphSubstitutionTable;
 import org.apache.fop.complexscripts.fonts.Positionable;
 import org.apache.fop.complexscripts.fonts.Substitutable;
 import org.apache.fop.complexscripts.util.GlyphSequence;
 import org.apache.fop.util.CharUtilities;

 /**
  * Generic MultiByte (CID) font
  */
 public class MultiByteFont extends CIDFont implements Substitutable, Positionable {

     /** logging instance */
     private static final Log log // CSOK: ConstantNameCheck
         = LogFactory.getLog(MultiByteFont.class);

     private String ttcName;
     private String encoding = "Identity-H";

     private int defaultWidth;
     private CIDFontType cidType = CIDFontType.CIDTYPE2;

     private final CIDSet cidSet;

     /* advanced typographic support */
     private GlyphDefinitionTable gdef;
     private GlyphSubstitutionTable gsub;
     private GlyphPositioningTable gpos;

     /* dynamic private use (character) mappings */
     private int numMapped;
     private int numUnmapped;
     private int nextPrivateUse = 0xE000;
     private int firstPrivate;
     private int lastPrivate;
     private int firstUnmapped;
     private int lastUnmapped;

     /**
      * Default constructor
      */
     public MultiByteFont(InternalResourceResolver resourceResolver, EmbeddingMode embeddingMode) {
         super(resourceResolver);
         setFontType(FontType.TYPE0);
         setEmbeddingMode(embeddingMode);
         if (embeddingMode != EmbeddingMode.FULL) {
             cidSet = new CIDSubset(this);
         } else {
             cidSet = new CIDFull(this);
         }
     }

     /** {@inheritDoc} */
     @Override
     public int getDefaultWidth() {
         return defaultWidth;
     }

     /** {@inheritDoc} */
     @Override
     public String getRegistry() {
         return "Adobe";
     }

     /** {@inheritDoc} */
     @Override
     public String getOrdering() {
         return "UCS";
     }

     /** {@inheritDoc} */
     @Override
     public int getSupplement() {
         return 0;
     }

     /** {@inheritDoc} */
     @Override
     public CIDFontType getCIDType() {
         return cidType;
     }

     /**
      * Sets the CIDType.
      * @param cidType The cidType to set
      */
     public void setCIDType(CIDFontType cidType) {
         this.cidType = cidType;
     }

     /** {@inheritDoc} */
     @Override
     public String getEmbedFontName() {
         if (isEmbeddable()) {
             return FontUtil.stripWhiteSpace(super.getFontName());
         } else {
             return super.getFontName();
         }
     }

     /** {@inheritDoc} */
     public boolean isEmbeddable() {
         return !(getEmbedFileURI() == null && getEmbedResourceName() == null);
     }

     public boolean isSubsetEmbedded() {
         if (getEmbeddingMode() == EmbeddingMode.FULL) {
             return false;
         }
         return true;
     }

     /** {@inheritDoc} */
     @Override
     public CIDSet getCIDSet() {
         return this.cidSet;
     }

     /** {@inheritDoc} */
     @Override
     public String getEncodingName() {
         return encoding;
     }

     /** {@inheritDoc} */
     public int getWidth(int i, int size) {
         if (isEmbeddable()) {
             int glyphIndex = cidSet.getOriginalGlyphIndex(i);
             return size * width[glyphIndex];
         } else {
             return size * width[i];
         }
     }

     /** {@inheritDoc} */
     public int[] getWidths() {
         int[] arr = new int[width.length];
         System.arraycopy(width, 0, arr, 0, width.length);
         return arr;
     }

     /**
      * Returns the glyph index for a Unicode character. The method returns 0 if there's no
      * such glyph in the character map.
      * @param c the Unicode character index
      * @return the glyph index (or 0 if the glyph is not available)
      */
     // [TBD] - needs optimization, i.e., change from linear search to binary search
     private int findGlyphIndex(int c) {
         int idx = c;
         int retIdx = SingleByteEncoding.NOT_FOUND_CODE_POINT;

         for (int i = 0; (i < cmap.length) && retIdx == 0; i++) {
             if (cmap[i].getUnicodeStart() <= idx
                     && cmap[i].getUnicodeEnd() >= idx) {

                 retIdx = cmap[i].getGlyphStartIndex()
                     + idx
                     - cmap[i].getUnicodeStart();
             }
         }
         return retIdx;
     }

     /**
      * Add a private use mapping {PU,GI} to the existing character map.
      * N.B. Does not insert in order, merely appends to end of existing map.
      */
     private synchronized void addPrivateUseMapping ( int pu, int gi ) {
         assert findGlyphIndex ( pu ) == SingleByteEncoding.NOT_FOUND_CODE_POINT;
         CMapSegment[] oldCmap = cmap;
         int cmapLength = oldCmap.length;
         CMapSegment[] newCmap = new CMapSegment [ cmapLength + 1 ];
         System.arraycopy ( oldCmap, 0, newCmap, 0, cmapLength );
         newCmap [ cmapLength ] = new CMapSegment ( pu, pu, gi );
         cmap = newCmap;
     }

     /**
      * Given a glyph index, create a new private use mapping, augmenting the bfentries
      * table. This is needed to accommodate the presence of an (output) glyph index in a
      * complex script glyph substitution that does not correspond to a character in the
      * font's CMAP.  The creation of such private use mappings is deferred until an
      * attempt is actually made to perform the reverse lookup from the glyph index. This
      * is necessary in order to avoid exhausting the private use space on fonts containing
      * many such non-mapped glyph indices, if these mappings had been created statically
      * at font load time.
      * @param gi glyph index
      * @returns unicode scalar value
      */
     private int createPrivateUseMapping ( int gi ) {
         while ( ( nextPrivateUse < 0xF900 )
                 && ( findGlyphIndex(nextPrivateUse) != SingleByteEncoding.NOT_FOUND_CODE_POINT ) ) {
             nextPrivateUse++;
         }
         if ( nextPrivateUse < 0xF900 ) {
             int pu = nextPrivateUse;
             addPrivateUseMapping ( pu, gi );
             if ( firstPrivate == 0 ) {
                 firstPrivate = pu;
             }
             lastPrivate = pu;
             numMapped++;
             if (log.isDebugEnabled()) {
                 log.debug ( "Create private use mapping from "
                             + CharUtilities.format ( pu )
                             + " to glyph index " + gi
                             + " in font '" + getFullName() + "'" );
             }
             return pu;
         } else {
             if ( firstUnmapped == 0 ) {
                 firstUnmapped = gi;
             }
             lastUnmapped = gi;
             numUnmapped++;
             log.warn ( "Exhausted private use area: unable to map "
                        + numUnmapped + " glyphs in glyph index range ["
                        + firstUnmapped + "," + lastUnmapped
                        + "] (inclusive) of font '" + getFullName() + "'" );
             return 0;
         }
     }

     /**
      * Returns the Unicode scalar value that corresponds to the glyph index. If more than
      * one correspondence exists, then the first one is returned (ordered by bfentries[]).
      * @param gi glyph index
      * @returns unicode scalar value
      */
     // [TBD] - needs optimization, i.e., change from linear search to binary search
     private int findCharacterFromGlyphIndex ( int gi, boolean augment ) {
         int cc = 0;
         for ( int i = 0, n = cmap.length; i < n; i++ ) {
             CMapSegment segment = cmap [ i ];
             int s = segment.getGlyphStartIndex();
             int e = s + ( segment.getUnicodeEnd() - segment.getUnicodeStart() );
             if ( ( gi >= s ) && ( gi <= e ) ) {
                 cc = segment.getUnicodeStart() + ( gi - s );
                 break;
             }
         }
         if ( ( cc == 0 ) && augment ) {
             cc = createPrivateUseMapping ( gi );
         }
         return cc;
     }

     private int findCharacterFromGlyphIndex ( int gi ) {
         return findCharacterFromGlyphIndex ( gi, true );
     }


     /** {@inheritDoc} */
     @Override
     public char mapChar(char c) {
         notifyMapOperation();
         int glyphIndex = findGlyphIndex(c);
         if (glyphIndex == SingleByteEncoding.NOT_FOUND_CODE_POINT) {
             warnMissingGlyph(c);
             glyphIndex = findGlyphIndex(Typeface.NOT_FOUND);
         }
         if (isEmbeddable()) {
             glyphIndex = cidSet.mapChar(glyphIndex, c);
         }
         return (char) glyphIndex;
     }

     protected BitSet getGlyphIndices() {
         BitSet bitset = new BitSet();
         bitset.set(0);
         bitset.set(1);
         bitset.set(2);
         for (int i = 0; i < cmap.length; i++) {
             int start = cmap[i].getUnicodeStart();
             int end = cmap[i].getUnicodeEnd();
             int glyphIndex = cmap[i].getGlyphStartIndex();
             while (start++ < end + 1) {
                 bitset.set(glyphIndex++);
             }
         }
         return bitset;
     }

     protected char[] getChars() {
         // the width array is set when the font is built
         char[] chars = new char[width.length];
         for (int i = 0; i < cmap.length; i++) {
             int start = cmap[i].getUnicodeStart();
             int end = cmap[i].getUnicodeEnd();
             int glyphIndex = cmap[i].getGlyphStartIndex();
             while (start < end + 1) {
                 chars[glyphIndex++] = (char) start++;
             }
         }
         return chars;
     }

     /** {@inheritDoc} */
     @Override
     public boolean hasChar(char c) {
         return (findGlyphIndex(c) != SingleByteEncoding.NOT_FOUND_CODE_POINT);
     }

     /**
      * Sets the defaultWidth.
      * @param defaultWidth The defaultWidth to set
      */
     public void setDefaultWidth(int defaultWidth) {
         this.defaultWidth = defaultWidth;
     }

     /**
      * Returns the TrueType Collection Name.
      * @return the TrueType Collection Name
      */
     public String getTTCName() {
         return ttcName;
     }

     /**
      * Sets the the TrueType Collection Name.
      * @param ttcName the TrueType Collection Name
      */
     public void setTTCName(String ttcName) {
         this.ttcName = ttcName;
     }

     /**
      * Sets the width array.
      * @param wds array of widths.
      */
     public void setWidthArray(int[] wds) {
         this.width = wds;
     }

     /**
      * Returns a Map of used Glyphs.
      * @return Map Map of used Glyphs
      */
     public Map<Integer, Integer> getUsedGlyphs() {
         return cidSet.getGlyphs();
     }

     /**
      * Establishes the glyph definition table.
      * @param gdef the glyph definition table to be used by this font
      */
     public void setGDEF ( GlyphDefinitionTable gdef ) {
         if ( ( this.gdef == null ) || ( gdef == null ) ) {
             this.gdef = gdef;
         } else {
             throw new IllegalStateException ( "font already associated with GDEF table" );
         }
     }

     /**
      * Obtain glyph definition table.
      * @return glyph definition table or null if none is associated with font
      */
     public GlyphDefinitionTable getGDEF() {
         return gdef;
     }

     /**
      * Establishes the glyph substitution table.
      * @param gsub the glyph substitution table to be used by this font
      */
     public void setGSUB ( GlyphSubstitutionTable gsub ) {
         if ( ( this.gsub == null ) || ( gsub == null ) ) {
             this.gsub = gsub;
         } else {
             throw new IllegalStateException ( "font already associated with GSUB table" );
         }
     }

     /**
      * Obtain glyph substitution table.
      * @return glyph substitution table or null if none is associated with font
      */
     public GlyphSubstitutionTable getGSUB() {
         return gsub;
     }

     /**
      * Establishes the glyph positioning table.
      * @param gpos the glyph positioning table to be used by this font
      */
     public void setGPOS ( GlyphPositioningTable gpos ) {
         if ( ( this.gpos == null ) || ( gpos == null ) ) {
             this.gpos = gpos;
         } else {
             throw new IllegalStateException ( "font already associated with GPOS table" );
         }
     }

     /**
      * Obtain glyph positioning table.
      * @return glyph positioning table or null if none is associated with font
      */
     public GlyphPositioningTable getGPOS() {
         return gpos;
     }

     /** {@inheritDoc} */
     public boolean performsSubstitution() {
         return gsub != null;
     }

     /** {@inheritDoc} */
     public CharSequence performSubstitution ( CharSequence cs, String script, String language ) {
         if ( gsub != null ) {
             GlyphSequence igs = mapCharsToGlyphs ( cs );
             GlyphSequence ogs = gsub.substitute ( igs, script, language );
             CharSequence ocs = mapGlyphsToChars ( ogs );
             return ocs;
         } else {
             return cs;
         }
     }

     /** {@inheritDoc} */
     public CharSequence reorderCombiningMarks
         ( CharSequence cs, int[][] gpa, String script, String language ) {
         if ( gdef != null ) {
             GlyphSequence igs = mapCharsToGlyphs ( cs );
             GlyphSequence ogs = gdef.reorderCombiningMarks ( igs, gpa, script, language );
             CharSequence ocs = mapGlyphsToChars ( ogs );
             return ocs;
         } else {
             return cs;
         }
     }

     /** {@inheritDoc} */
     public boolean performsPositioning() {
         return gpos != null;
     }

     /** {@inheritDoc} */
     public int[][]
         performPositioning ( CharSequence cs, String script, String language, int fontSize ) {
         if ( gpos != null ) {
             GlyphSequence gs = mapCharsToGlyphs ( cs );
             int[][] adjustments = new int [ gs.getGlyphCount() ] [ 4 ];
             if ( gpos.position ( gs, script, language, fontSize, this.width, adjustments ) ) {
                 return scaleAdjustments ( adjustments, fontSize );
             } else {
                 return null;
             }
         } else {
             return null;
         }
     }

     /** {@inheritDoc} */
     public int[][] performPositioning ( CharSequence cs, String script, String language ) {
         throw new UnsupportedOperationException();
     }


     private int[][] scaleAdjustments ( int[][] adjustments, int fontSize ) {
         if ( adjustments != null ) {
             for ( int i = 0, n = adjustments.length; i < n; i++ ) {
                 int[] gpa = adjustments [ i ];
                 for ( int k = 0; k < 4; k++ ) {
                     gpa [ k ] = ( gpa [ k ] * fontSize ) / 1000;
                 }
             }
             return adjustments;
         } else {
             return null;
         }
     }

     /**
      * Map sequence CS, comprising a sequence of UTF-16 encoded Unicode Code Points, to
      * an output character sequence GS, comprising a sequence of Glyph Indices. N.B. Unlike
      * mapChar(), this method does not make use of embedded subset encodings.
      * @param cs a CharSequence containing UTF-16 encoded Unicode characters
      * @returns a CharSequence containing glyph indices
      */
     private GlyphSequence mapCharsToGlyphs ( CharSequence cs ) {
         IntBuffer cb = IntBuffer.allocate ( cs.length() );
         IntBuffer gb = IntBuffer.allocate ( cs.length() );
         int gi;
         int giMissing = findGlyphIndex ( Typeface.NOT_FOUND );
         for ( int i = 0, n = cs.length(); i < n; i++ ) {
             int cc = cs.charAt ( i );
             if ( ( cc >= 0xD800 ) && ( cc < 0xDC00 ) ) {
                 if ( ( i + 1 ) < n ) {
                     int sh = cc;
                     int sl = cs.charAt ( ++i );
                     if ( ( sl >= 0xDC00 ) && ( sl < 0xE000 ) ) {
                         cc = 0x10000 + ( ( sh - 0xD800 ) << 10 ) + ( ( sl - 0xDC00 ) << 0 );
                     } else {
                         throw new IllegalArgumentException
                             (  "ill-formed UTF-16 sequence, "
                                + "contains isolated high surrogate at index " + i );
                     }
                 } else {
                     throw new IllegalArgumentException
                         ( "ill-formed UTF-16 sequence, "
                           + "contains isolated high surrogate at end of sequence" );
                 }
             } else if ( ( cc >= 0xDC00 ) && ( cc < 0xE000 ) ) {
                 throw new IllegalArgumentException
                     ( "ill-formed UTF-16 sequence, "
                       + "contains isolated low surrogate at index " + i );
             }
             notifyMapOperation();
             gi = findGlyphIndex ( cc );
             if ( gi == SingleByteEncoding.NOT_FOUND_CODE_POINT ) {
                 warnMissingGlyph ( (char) cc );
                 gi = giMissing;
             }
             cb.put ( cc );
             gb.put ( gi );
         }
         cb.flip();
         gb.flip();
         return new GlyphSequence ( cb, gb, null );
     }

     /**
      * Map sequence GS, comprising a sequence of Glyph Indices, to output sequence CS,
      * comprising a sequence of UTF-16 encoded Unicode Code Points.
      * @param gs a GlyphSequence containing glyph indices
      * @returns a CharSequence containing UTF-16 encoded Unicode characters
      */
     private CharSequence mapGlyphsToChars ( GlyphSequence gs ) {
         int ng = gs.getGlyphCount();
         CharBuffer cb = CharBuffer.allocate ( ng );
         int ccMissing = Typeface.NOT_FOUND;
         for ( int i = 0, n = ng; i < n; i++ ) {
             int gi = gs.getGlyph ( i );
             int cc = findCharacterFromGlyphIndex ( gi );
             if ( ( cc == 0 ) || ( cc > 0x10FFFF ) ) {
                 cc = ccMissing;
                 log.warn("Unable to map glyph index " + gi
                          + " to Unicode scalar in font '"
                          + getFullName() + "', substituting missing character '"
                          + (char) cc + "'");
             }
             if ( cc > 0x00FFFF ) {
                 int sh;
                 int sl;
                 cc -= 0x10000;
                 sh = ( ( cc >> 10 ) & 0x3FF ) + 0xD800;
                 sl = ( ( cc >>  0 ) & 0x3FF ) + 0xDC00;
                 cb.put ( (char) sh );
                 cb.put ( (char) sl );
             } else {
                 cb.put ( (char) cc );
             }
         }
         cb.flip();
         return cb;
     }

 }
	/*
	* 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.fonts;

	import java.nio.CharBuffer;
	import java.nio.IntBuffer;
	import java.util.BitSet;
	import java.util.Map;

	import org.apache.commons.logging.Log;
	import org.apache.commons.logging.LogFactory;

	import org.apache.fop.apps.io.InternalResourceResolver;
	import org.apache.fop.complexscripts.fonts.GlyphDefinitionTable;
	import org.apache.fop.complexscripts.fonts.GlyphPositioningTable;
	import org.apache.fop.complexscripts.fonts.GlyphSubstitutionTable;
	import org.apache.fop.complexscripts.fonts.Positionable;
	import org.apache.fop.complexscripts.fonts.Substitutable;
	import org.apache.fop.complexscripts.util.GlyphSequence;
	import org.apache.fop.util.CharUtilities;

	/**
	* Generic MultiByte (CID) font
	*/
	public class MultiByteFont extends CIDFont implements Substitutable, Positionable {

	/** logging instance */
	private static final Log log // CSOK: ConstantNameCheck
	= LogFactory.getLog(MultiByteFont.class);

	private String ttcName;
	private String encoding = "Identity-H";

	private int defaultWidth;
	private CIDFontType cidType = CIDFontType.CIDTYPE2;

	private final CIDSet cidSet;

	/* advanced typographic support */
	private GlyphDefinitionTable gdef;
	private GlyphSubstitutionTable gsub;
	private GlyphPositioningTable gpos;

	/* dynamic private use (character) mappings */
	private int numMapped;
	private int numUnmapped;
	private int nextPrivateUse = 0xE000;
	private int firstPrivate;
	private int lastPrivate;
	private int firstUnmapped;
	private int lastUnmapped;

	/**
	* Default constructor
	*/
	public MultiByteFont(InternalResourceResolver resourceResolver, EmbeddingMode embeddingMode) {
	super(resourceResolver);
	setFontType(FontType.TYPE0);
	setEmbeddingMode(embeddingMode);
	if (embeddingMode != EmbeddingMode.FULL) {
	cidSet = new CIDSubset(this);
	} else {
	cidSet = new CIDFull(this);
	}
	}

	/** {@inheritDoc} */
	@Override
	public int getDefaultWidth() {
	return defaultWidth;
	}

	/** {@inheritDoc} */
	@Override
	public String getRegistry() {
	return "Adobe";
	}

	/** {@inheritDoc} */
	@Override
	public String getOrdering() {
	return "UCS";
	}

	/** {@inheritDoc} */
	@Override
	public int getSupplement() {
	return 0;
	}

	/** {@inheritDoc} */
	@Override
	public CIDFontType getCIDType() {
	return cidType;
	}

	/**
	* Sets the CIDType.
	* @param cidType The cidType to set
	*/
	public void setCIDType(CIDFontType cidType) {
	this.cidType = cidType;
	}

	/** {@inheritDoc} */
	@Override
	public String getEmbedFontName() {
	if (isEmbeddable()) {
	return FontUtil.stripWhiteSpace(super.getFontName());
	} else {
	return super.getFontName();
	}
	}

	/** {@inheritDoc} */
	public boolean isEmbeddable() {
	return !(getEmbedFileURI() == null && getEmbedResourceName() == null);
	}

	public boolean isSubsetEmbedded() {
	if (getEmbeddingMode() == EmbeddingMode.FULL) {
	return false;
	}
	return true;
	}

	/** {@inheritDoc} */
	@Override
	public CIDSet getCIDSet() {
	return this.cidSet;
	}

	/** {@inheritDoc} */
	@Override
	public String getEncodingName() {
	return encoding;
	}

	/** {@inheritDoc} */
	public int getWidth(int i, int size) {
	if (isEmbeddable()) {
	int glyphIndex = cidSet.getOriginalGlyphIndex(i);
	return size * width[glyphIndex];
	} else {
	return size * width[i];
	}
	}

	/** {@inheritDoc} */
	public int[] getWidths() {
	int[] arr = new int[width.length];
	System.arraycopy(width, 0, arr, 0, width.length);
	return arr;
	}

	/**
	* Returns the glyph index for a Unicode character. The method returns 0 if there's no
	* such glyph in the character map.
	* @param c the Unicode character index
	* @return the glyph index (or 0 if the glyph is not available)
	*/
	// [TBD] - needs optimization, i.e., change from linear search to binary search
	private int findGlyphIndex(int c) {
	int idx = c;
	int retIdx = SingleByteEncoding.NOT_FOUND_CODE_POINT;

	for (int i = 0; (i < cmap.length) && retIdx == 0; i++) {
	if (cmap[i].getUnicodeStart() <= idx
	&& cmap[i].getUnicodeEnd() >= idx) {

	retIdx = cmap[i].getGlyphStartIndex()
	+ idx
	- cmap[i].getUnicodeStart();
	}
	}
	return retIdx;
	}

	/**
	* Add a private use mapping {PU,GI} to the existing character map.
	* N.B. Does not insert in order, merely appends to end of existing map.
	*/
	private synchronized void addPrivateUseMapping ( int pu, int gi ) {
	assert findGlyphIndex ( pu ) == SingleByteEncoding.NOT_FOUND_CODE_POINT;
	CMapSegment[] oldCmap = cmap;
	int cmapLength = oldCmap.length;
	CMapSegment[] newCmap = new CMapSegment [ cmapLength + 1 ];
	System.arraycopy ( oldCmap, 0, newCmap, 0, cmapLength );
	newCmap [ cmapLength ] = new CMapSegment ( pu, pu, gi );
	cmap = newCmap;
	}

	/**
	* Given a glyph index, create a new private use mapping, augmenting the bfentries
	* table. This is needed to accommodate the presence of an (output) glyph index in a
	* complex script glyph substitution that does not correspond to a character in the
	* font's CMAP. The creation of such private use mappings is deferred until an
	* attempt is actually made to perform the reverse lookup from the glyph index. This
	* is necessary in order to avoid exhausting the private use space on fonts containing
	* many such non-mapped glyph indices, if these mappings had been created statically
	* at font load time.
	* @param gi glyph index
	* @returns unicode scalar value
	*/
	private int createPrivateUseMapping ( int gi ) {
	while ( ( nextPrivateUse < 0xF900 )
	&& ( findGlyphIndex(nextPrivateUse) != SingleByteEncoding.NOT_FOUND_CODE_POINT ) ) {
	nextPrivateUse++;
	}
	if ( nextPrivateUse < 0xF900 ) {
	int pu = nextPrivateUse;
	addPrivateUseMapping ( pu, gi );
	if ( firstPrivate == 0 ) {
	firstPrivate = pu;
	}
	lastPrivate = pu;
	numMapped++;
	if (log.isDebugEnabled()) {
	log.debug ( "Create private use mapping from "
	+ CharUtilities.format ( pu )
	+ " to glyph index " + gi
	+ " in font '" + getFullName() + "'" );
	}
	return pu;
	} else {
	if ( firstUnmapped == 0 ) {
	firstUnmapped = gi;
	}
	lastUnmapped = gi;
	numUnmapped++;
	log.warn ( "Exhausted private use area: unable to map "
	+ numUnmapped + " glyphs in glyph index range ["
	+ firstUnmapped + "," + lastUnmapped
	+ "] (inclusive) of font '" + getFullName() + "'" );
	return 0;
	}
	}

	/**
	* Returns the Unicode scalar value that corresponds to the glyph index. If more than
	* one correspondence exists, then the first one is returned (ordered by bfentries[]).
	* @param gi glyph index
	* @returns unicode scalar value
	*/
	// [TBD] - needs optimization, i.e., change from linear search to binary search
	private int findCharacterFromGlyphIndex ( int gi, boolean augment ) {
	int cc = 0;
	for ( int i = 0, n = cmap.length; i < n; i++ ) {
	CMapSegment segment = cmap [ i ];
	int s = segment.getGlyphStartIndex();
	int e = s + ( segment.getUnicodeEnd() - segment.getUnicodeStart() );
	if ( ( gi >= s ) && ( gi <= e ) ) {
	cc = segment.getUnicodeStart() + ( gi - s );
	break;
	}
	}
	if ( ( cc == 0 ) && augment ) {
	cc = createPrivateUseMapping ( gi );
	}
	return cc;
	}

	private int findCharacterFromGlyphIndex ( int gi ) {
	return findCharacterFromGlyphIndex ( gi, true );
	}


	/** {@inheritDoc} */
	@Override
	public char mapChar(char c) {
	notifyMapOperation();
	int glyphIndex = findGlyphIndex(c);
	if (glyphIndex == SingleByteEncoding.NOT_FOUND_CODE_POINT) {
	warnMissingGlyph(c);
	glyphIndex = findGlyphIndex(Typeface.NOT_FOUND);
	}
	if (isEmbeddable()) {
	glyphIndex = cidSet.mapChar(glyphIndex, c);
	}
	return (char) glyphIndex;
	}

	protected BitSet getGlyphIndices() {
	BitSet bitset = new BitSet();
	bitset.set(0);
	bitset.set(1);
	bitset.set(2);
	for (int i = 0; i < cmap.length; i++) {
	int start = cmap[i].getUnicodeStart();
	int end = cmap[i].getUnicodeEnd();
	int glyphIndex = cmap[i].getGlyphStartIndex();
	while (start++ < end + 1) {
	bitset.set(glyphIndex++);
	}
	}
	return bitset;
	}

	protected char[] getChars() {
	// the width array is set when the font is built
	char[] chars = new char[width.length];
	for (int i = 0; i < cmap.length; i++) {
	int start = cmap[i].getUnicodeStart();
	int end = cmap[i].getUnicodeEnd();
	int glyphIndex = cmap[i].getGlyphStartIndex();
	while (start < end + 1) {
	chars[glyphIndex++] = (char) start++;
	}
	}
	return chars;
	}

	/** {@inheritDoc} */
	@Override
	public boolean hasChar(char c) {
	return (findGlyphIndex(c) != SingleByteEncoding.NOT_FOUND_CODE_POINT);
	}

	/**
	* Sets the defaultWidth.
	* @param defaultWidth The defaultWidth to set
	*/
	public void setDefaultWidth(int defaultWidth) {
	this.defaultWidth = defaultWidth;
	}

	/**
	* Returns the TrueType Collection Name.
	* @return the TrueType Collection Name
	*/
	public String getTTCName() {
	return ttcName;
	}

	/**
	* Sets the the TrueType Collection Name.
	* @param ttcName the TrueType Collection Name
	*/
	public void setTTCName(String ttcName) {
	this.ttcName = ttcName;
	}

	/**
	* Sets the width array.
	* @param wds array of widths.
	*/
	public void setWidthArray(int[] wds) {
	this.width = wds;
	}

	/**
	* Returns a Map of used Glyphs.
	* @return Map Map of used Glyphs
	*/
	public Map<Integer, Integer> getUsedGlyphs() {
	return cidSet.getGlyphs();
	}

	/**
	* Establishes the glyph definition table.
	* @param gdef the glyph definition table to be used by this font
	*/
	public void setGDEF ( GlyphDefinitionTable gdef ) {
	if ( ( this.gdef == null ) \|\| ( gdef == null ) ) {
	this.gdef = gdef;
	} else {
	throw new IllegalStateException ( "font already associated with GDEF table" );
	}
	}

	/**
	* Obtain glyph definition table.
	* @return glyph definition table or null if none is associated with font
	*/
	public GlyphDefinitionTable getGDEF() {
	return gdef;
	}

	/**
	* Establishes the glyph substitution table.
	* @param gsub the glyph substitution table to be used by this font
	*/
	public void setGSUB ( GlyphSubstitutionTable gsub ) {
	if ( ( this.gsub == null ) \|\| ( gsub == null ) ) {
	this.gsub = gsub;
	} else {
	throw new IllegalStateException ( "font already associated with GSUB table" );
	}
	}

	/**
	* Obtain glyph substitution table.
	* @return glyph substitution table or null if none is associated with font
	*/
	public GlyphSubstitutionTable getGSUB() {
	return gsub;
	}

	/**
	* Establishes the glyph positioning table.
	* @param gpos the glyph positioning table to be used by this font
	*/
	public void setGPOS ( GlyphPositioningTable gpos ) {
	if ( ( this.gpos == null ) \|\| ( gpos == null ) ) {
	this.gpos = gpos;
	} else {
	throw new IllegalStateException ( "font already associated with GPOS table" );
	}
	}

	/**
	* Obtain glyph positioning table.
	* @return glyph positioning table or null if none is associated with font
	*/
	public GlyphPositioningTable getGPOS() {
	return gpos;
	}

	/** {@inheritDoc} */
	public boolean performsSubstitution() {
	return gsub != null;
	}

	/** {@inheritDoc} */
	public CharSequence performSubstitution ( CharSequence cs, String script, String language ) {
	if ( gsub != null ) {
	GlyphSequence igs = mapCharsToGlyphs ( cs );
	GlyphSequence ogs = gsub.substitute ( igs, script, language );
	CharSequence ocs = mapGlyphsToChars ( ogs );
	return ocs;
	} else {
	return cs;
	}
	}

	/** {@inheritDoc} */
	public CharSequence reorderCombiningMarks
	( CharSequence cs, int[][] gpa, String script, String language ) {
	if ( gdef != null ) {
	GlyphSequence igs = mapCharsToGlyphs ( cs );
	GlyphSequence ogs = gdef.reorderCombiningMarks ( igs, gpa, script, language );
	CharSequence ocs = mapGlyphsToChars ( ogs );
	return ocs;
	} else {
	return cs;
	}
	}

	/** {@inheritDoc} */
	public boolean performsPositioning() {
	return gpos != null;
	}

	/** {@inheritDoc} */
	public int[][]
	performPositioning ( CharSequence cs, String script, String language, int fontSize ) {
	if ( gpos != null ) {
	GlyphSequence gs = mapCharsToGlyphs ( cs );
	int[][] adjustments = new int [ gs.getGlyphCount() ] [ 4 ];
	if ( gpos.position ( gs, script, language, fontSize, this.width, adjustments ) ) {
	return scaleAdjustments ( adjustments, fontSize );
	} else {
	return null;
	}
	} else {
	return null;
	}
	}

	/** {@inheritDoc} */
	public int[][] performPositioning ( CharSequence cs, String script, String language ) {
	throw new UnsupportedOperationException();
	}


	private int[][] scaleAdjustments ( int[][] adjustments, int fontSize ) {
	if ( adjustments != null ) {
	for ( int i = 0, n = adjustments.length; i < n; i++ ) {
	int[] gpa = adjustments [ i ];
	for ( int k = 0; k < 4; k++ ) {
	gpa [ k ] = ( gpa [ k ] * fontSize ) / 1000;
	}
	}
	return adjustments;
	} else {
	return null;
	}
	}

	/**
	* Map sequence CS, comprising a sequence of UTF-16 encoded Unicode Code Points, to
	* an output character sequence GS, comprising a sequence of Glyph Indices. N.B. Unlike
	* mapChar(), this method does not make use of embedded subset encodings.
	* @param cs a CharSequence containing UTF-16 encoded Unicode characters
	* @returns a CharSequence containing glyph indices
	*/
	private GlyphSequence mapCharsToGlyphs ( CharSequence cs ) {
	IntBuffer cb = IntBuffer.allocate ( cs.length() );
	IntBuffer gb = IntBuffer.allocate ( cs.length() );
	int gi;
	int giMissing = findGlyphIndex ( Typeface.NOT_FOUND );
	for ( int i = 0, n = cs.length(); i < n; i++ ) {
	int cc = cs.charAt ( i );
	if ( ( cc >= 0xD800 ) && ( cc < 0xDC00 ) ) {
	if ( ( i + 1 ) < n ) {
	int sh = cc;
	int sl = cs.charAt ( ++i );
	if ( ( sl >= 0xDC00 ) && ( sl < 0xE000 ) ) {
	cc = 0x10000 + ( ( sh - 0xD800 ) << 10 ) + ( ( sl - 0xDC00 ) << 0 );
	} else {
	throw new IllegalArgumentException
	( "ill-formed UTF-16 sequence, "
	+ "contains isolated high surrogate at index " + i );
	}
	} else {
	throw new IllegalArgumentException
	( "ill-formed UTF-16 sequence, "
	+ "contains isolated high surrogate at end of sequence" );
	}
	} else if ( ( cc >= 0xDC00 ) && ( cc < 0xE000 ) ) {
	throw new IllegalArgumentException
	( "ill-formed UTF-16 sequence, "
	+ "contains isolated low surrogate at index " + i );
	}
	notifyMapOperation();
	gi = findGlyphIndex ( cc );
	if ( gi == SingleByteEncoding.NOT_FOUND_CODE_POINT ) {
	warnMissingGlyph ( (char) cc );
	gi = giMissing;
	}
	cb.put ( cc );
	gb.put ( gi );
	}
	cb.flip();
	gb.flip();
	return new GlyphSequence ( cb, gb, null );
	}

	/**
	* Map sequence GS, comprising a sequence of Glyph Indices, to output sequence CS,
	* comprising a sequence of UTF-16 encoded Unicode Code Points.
	* @param gs a GlyphSequence containing glyph indices
	* @returns a CharSequence containing UTF-16 encoded Unicode characters
	*/
	private CharSequence mapGlyphsToChars ( GlyphSequence gs ) {
	int ng = gs.getGlyphCount();
	CharBuffer cb = CharBuffer.allocate ( ng );
	int ccMissing = Typeface.NOT_FOUND;
	for ( int i = 0, n = ng; i < n; i++ ) {
	int gi = gs.getGlyph ( i );
	int cc = findCharacterFromGlyphIndex ( gi );
	if ( ( cc == 0 ) \|\| ( cc > 0x10FFFF ) ) {
	cc = ccMissing;
	log.warn("Unable to map glyph index " + gi
	+ " to Unicode scalar in font '"
	+ getFullName() + "', substituting missing character '"
	+ (char) cc + "'");
	}
	if ( cc > 0x00FFFF ) {
	int sh;
	int sl;
	cc -= 0x10000;
	sh = ( ( cc >> 10 ) & 0x3FF ) + 0xD800;
	sl = ( ( cc >> 0 ) & 0x3FF ) + 0xDC00;
	cb.put ( (char) sh );
	cb.put ( (char) sl );
	} else {
	cb.put ( (char) cc );
	}
	}
	cb.flip();
	return cb;
	}

	}