fop-core/src/main/java/org/apache/fop/fonts/truetype/GlyfTable.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.truetype;

 import java.io.IOException;
 import java.util.HashSet;
 import java.util.Map;
 import java.util.Set;
 import java.util.TreeSet;

 /**
  * This "glyf" table in a TrueType font file contains information that describes the glyphs. This
  * class is responsible for creating a subset of the "glyf" table given a set of glyph indices.
  */
 public class GlyfTable {

     private final OFMtxEntry[] mtxTab;

     private final long tableOffset;

     private final Set<Long> remappedComposites;

     protected final Map<Integer, Integer> subset;

     private final FontFileReader in;

     /** All the composite glyphs that appear in the subset. */
     private Set<Integer> compositeGlyphs = new TreeSet<Integer>();

     /** All the glyphs that are composed, but do not appear in the subset. */
     protected Set<Integer> composedGlyphs = new TreeSet<Integer>();

     public GlyfTable(FontFileReader in, OFMtxEntry[] metrics, OFDirTabEntry dirTableEntry,
                         Map<Integer, Integer> glyphs) throws IOException {
         mtxTab = metrics;
         tableOffset = dirTableEntry.getOffset();
         remappedComposites = new HashSet<Long>();
         this.subset = glyphs;
         this.in = in;
     }

     private static enum GlyfFlags {

         ARG_1_AND_2_ARE_WORDS(4, 2),
         ARGS_ARE_XY_VALUES,
         ROUND_XY_TO_GRID,
         WE_HAVE_A_SCALE(2),
         RESERVED,
         MORE_COMPONENTS,
         WE_HAVE_AN_X_AND_Y_SCALE(4),
         WE_HAVE_A_TWO_BY_TWO(8),
         WE_HAVE_INSTRUCTIONS,
         USE_MY_METRICS,
         OVERLAP_COMPOUND,
         SCALED_COMPONENT_OFFSET,
         UNSCALED_COMPONENT_OFFSET;

         private final int bitMask;
         private final int argsCountIfSet;
         private final int argsCountIfNotSet;

         private GlyfFlags(int argsCountIfSet, int argsCountIfNotSet) {
             this.bitMask = 1 << this.ordinal();
             this.argsCountIfSet = argsCountIfSet;
             this.argsCountIfNotSet = argsCountIfNotSet;
         }

         private GlyfFlags(int argsCountIfSet) {
             this(argsCountIfSet, 0);
         }

         private GlyfFlags() {
             this(0, 0);
         }

         /**
          * Calculates, from the given flags, the offset to the next glyph index.
          *
          * @param flags the glyph data flags
          * @return offset to the next glyph if any, or 0
          */
         static int getOffsetToNextComposedGlyf(int flags) {
             int offset = 0;
             for (GlyfFlags flag : GlyfFlags.values()) {
                 offset += (flags & flag.bitMask) > 0 ? flag.argsCountIfSet : flag.argsCountIfNotSet;
             }
             return offset;
         }

         /**
          * Checks the given flags to see if there is another composed glyph.
          *
          * @param flags the glyph data flags
          * @return true if there is another composed glyph, otherwise false.
          */
         static boolean hasMoreComposites(int flags) {
             return (flags & MORE_COMPONENTS.bitMask) > 0;
         }
     }

     /**
      * Populates the map of subset glyphs with all the glyphs that compose the glyphs in the subset.
      * This also re-maps the indices of composed glyphs to their new index in the subset font.
      *
      * @throws IOException an I/O error
      */
     protected void populateGlyphsWithComposites() throws IOException {
         for (int indexInOriginal : subset.keySet()) {
             scanGlyphsRecursively(indexInOriginal);
         }

         addAllComposedGlyphsToSubset();

         for (int compositeGlyph : compositeGlyphs) {
             long offset = tableOffset + mtxTab[compositeGlyph].getOffset() + 10;
             if (!remappedComposites.contains(offset)) {
                 remapComposite(offset);
             }
         }
     }

     /**
      * Scans each glyph for any composed glyphs. This populates <code>compositeGlyphs</code> with
      * all the composite glyphs being used in the subset. This also populates <code>newGlyphs</code>
      * with any new glyphs that are composed and do not appear in the subset of glyphs.
      *
      * For example the double quote mark (") is often composed of two apostrophes ('), if an
      * apostrophe doesn't appear in the glyphs in the subset, it will be included and will be added
      * to newGlyphs.
      *
      * @param indexInOriginal the index of the glyph to test from the original font
      * @throws IOException an I/O error
      */
     private void scanGlyphsRecursively(int indexInOriginal) throws IOException {
         if (!subset.containsKey(indexInOriginal)) {
             composedGlyphs.add(indexInOriginal);
         }

         if (isComposite(indexInOriginal)) {
             compositeGlyphs.add(indexInOriginal);
             Set<Integer> composedGlyphs = retrieveComposedGlyphs(indexInOriginal);
             for (Integer composedGlyph : composedGlyphs) {
                 scanGlyphsRecursively(composedGlyph);
             }
         }
     }

     /**
      * Adds to the subset, all the glyphs that are composed by a glyph, but do not appear themselves
      * in the subset.
      */
     protected void addAllComposedGlyphsToSubset() {
         int newIndex = subset.size();
         for (int composedGlyph : composedGlyphs) {
             subset.put(composedGlyph, newIndex++);
         }
     }

     /**
      * Re-maps the index of composed glyphs in the original font to the index of the same glyph in
      * the subset font.
      *
      * @param glyphOffset the offset of the composite glyph
      * @throws IOException an I/O error
      */
     private void remapComposite(long glyphOffset) throws IOException {
         long currentGlyphOffset = glyphOffset;

         remappedComposites.add(currentGlyphOffset);

         int flags = 0;
         do {
             flags = in.readTTFUShort(currentGlyphOffset);
             int glyphIndex = in.readTTFUShort(currentGlyphOffset + 2);
             Integer indexInSubset = subset.get(glyphIndex);
             assert indexInSubset != null;
             /*
              * TODO: this should not be done here!! We're writing to the stream we're reading from,
              * this is asking for trouble! What should happen is when the glyph data is copied from
              * subset, the remapping should be done there. So the original stream is left untouched.
              */
             in.writeTTFUShort(currentGlyphOffset + 2, indexInSubset);

             currentGlyphOffset += 4 + GlyfFlags.getOffsetToNextComposedGlyf(flags);
         } while (GlyfFlags.hasMoreComposites(flags));
     }

     public boolean isComposite(int indexInOriginal) throws IOException {
         int numberOfContours = in.readTTFShort(tableOffset + mtxTab[indexInOriginal].getOffset());
         return numberOfContours < 0;
     }

     /**
      * Reads a composite glyph at a given index and retrieves all the glyph indices of contingent
      * composed glyphs.
      *
      * @param indexInOriginal the glyph index of the composite glyph
      * @return the set of glyph indices this glyph composes
      * @throws IOException an I/O error
      */
     public Set<Integer> retrieveComposedGlyphs(int indexInOriginal)
             throws IOException {
         Set<Integer> composedGlyphs = new HashSet<Integer>();
         long offset = tableOffset + mtxTab[indexInOriginal].getOffset() + 10;
         int flags = 0;
         do {
             flags = in.readTTFUShort(offset);
             composedGlyphs.add(in.readTTFUShort(offset + 2));
             offset += 4 + GlyfFlags.getOffsetToNextComposedGlyf(flags);
         } while (GlyfFlags.hasMoreComposites(flags));

         return composedGlyphs;
     }
 }
	/*
	* 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.truetype;

	import java.io.IOException;
	import java.util.HashSet;
	import java.util.Map;
	import java.util.Set;
	import java.util.TreeSet;

	/**
	* This "glyf" table in a TrueType font file contains information that describes the glyphs. This
	* class is responsible for creating a subset of the "glyf" table given a set of glyph indices.
	*/
	public class GlyfTable {

	private final OFMtxEntry[] mtxTab;

	private final long tableOffset;

	private final Set<Long> remappedComposites;

	protected final Map<Integer, Integer> subset;

	private final FontFileReader in;

	/** All the composite glyphs that appear in the subset. */
	private Set<Integer> compositeGlyphs = new TreeSet<Integer>();

	/** All the glyphs that are composed, but do not appear in the subset. */
	protected Set<Integer> composedGlyphs = new TreeSet<Integer>();

	public GlyfTable(FontFileReader in, OFMtxEntry[] metrics, OFDirTabEntry dirTableEntry,
	Map<Integer, Integer> glyphs) throws IOException {
	mtxTab = metrics;
	tableOffset = dirTableEntry.getOffset();
	remappedComposites = new HashSet<Long>();
	this.subset = glyphs;
	this.in = in;
	}

	private static enum GlyfFlags {

	ARG_1_AND_2_ARE_WORDS(4, 2),
	ARGS_ARE_XY_VALUES,
	ROUND_XY_TO_GRID,
	WE_HAVE_A_SCALE(2),
	RESERVED,
	MORE_COMPONENTS,
	WE_HAVE_AN_X_AND_Y_SCALE(4),
	WE_HAVE_A_TWO_BY_TWO(8),
	WE_HAVE_INSTRUCTIONS,
	USE_MY_METRICS,
	OVERLAP_COMPOUND,
	SCALED_COMPONENT_OFFSET,
	UNSCALED_COMPONENT_OFFSET;

	private final int bitMask;
	private final int argsCountIfSet;
	private final int argsCountIfNotSet;

	private GlyfFlags(int argsCountIfSet, int argsCountIfNotSet) {
	this.bitMask = 1 << this.ordinal();
	this.argsCountIfSet = argsCountIfSet;
	this.argsCountIfNotSet = argsCountIfNotSet;
	}

	private GlyfFlags(int argsCountIfSet) {
	this(argsCountIfSet, 0);
	}

	private GlyfFlags() {
	this(0, 0);
	}

	/**
	* Calculates, from the given flags, the offset to the next glyph index.
	*
	* @param flags the glyph data flags
	* @return offset to the next glyph if any, or 0
	*/
	static int getOffsetToNextComposedGlyf(int flags) {
	int offset = 0;
	for (GlyfFlags flag : GlyfFlags.values()) {
	offset += (flags & flag.bitMask) > 0 ? flag.argsCountIfSet : flag.argsCountIfNotSet;
	}
	return offset;
	}

	/**
	* Checks the given flags to see if there is another composed glyph.
	*
	* @param flags the glyph data flags
	* @return true if there is another composed glyph, otherwise false.
	*/
	static boolean hasMoreComposites(int flags) {
	return (flags & MORE_COMPONENTS.bitMask) > 0;
	}
	}

	/**
	* Populates the map of subset glyphs with all the glyphs that compose the glyphs in the subset.
	* This also re-maps the indices of composed glyphs to their new index in the subset font.
	*
	* @throws IOException an I/O error
	*/
	protected void populateGlyphsWithComposites() throws IOException {
	for (int indexInOriginal : subset.keySet()) {
	scanGlyphsRecursively(indexInOriginal);
	}

	addAllComposedGlyphsToSubset();

	for (int compositeGlyph : compositeGlyphs) {
	long offset = tableOffset + mtxTab[compositeGlyph].getOffset() + 10;
	if (!remappedComposites.contains(offset)) {
	remapComposite(offset);
	}
	}
	}

	/**
	* Scans each glyph for any composed glyphs. This populates <code>compositeGlyphs</code> with
	* all the composite glyphs being used in the subset. This also populates <code>newGlyphs</code>
	* with any new glyphs that are composed and do not appear in the subset of glyphs.
	*
	* For example the double quote mark (") is often composed of two apostrophes ('), if an
	* apostrophe doesn't appear in the glyphs in the subset, it will be included and will be added
	* to newGlyphs.
	*
	* @param indexInOriginal the index of the glyph to test from the original font
	* @throws IOException an I/O error
	*/
	private void scanGlyphsRecursively(int indexInOriginal) throws IOException {
	if (!subset.containsKey(indexInOriginal)) {
	composedGlyphs.add(indexInOriginal);
	}

	if (isComposite(indexInOriginal)) {
	compositeGlyphs.add(indexInOriginal);
	Set<Integer> composedGlyphs = retrieveComposedGlyphs(indexInOriginal);
	for (Integer composedGlyph : composedGlyphs) {
	scanGlyphsRecursively(composedGlyph);
	}
	}
	}

	/**
	* Adds to the subset, all the glyphs that are composed by a glyph, but do not appear themselves
	* in the subset.
	*/
	protected void addAllComposedGlyphsToSubset() {
	int newIndex = subset.size();
	for (int composedGlyph : composedGlyphs) {
	subset.put(composedGlyph, newIndex++);
	}
	}

	/**
	* Re-maps the index of composed glyphs in the original font to the index of the same glyph in
	* the subset font.
	*
	* @param glyphOffset the offset of the composite glyph
	* @throws IOException an I/O error
	*/
	private void remapComposite(long glyphOffset) throws IOException {
	long currentGlyphOffset = glyphOffset;

	remappedComposites.add(currentGlyphOffset);

	int flags = 0;
	do {
	flags = in.readTTFUShort(currentGlyphOffset);
	int glyphIndex = in.readTTFUShort(currentGlyphOffset + 2);
	Integer indexInSubset = subset.get(glyphIndex);
	assert indexInSubset != null;
	/*
	* TODO: this should not be done here!! We're writing to the stream we're reading from,
	* this is asking for trouble! What should happen is when the glyph data is copied from
	* subset, the remapping should be done there. So the original stream is left untouched.
	*/
	in.writeTTFUShort(currentGlyphOffset + 2, indexInSubset);

	currentGlyphOffset += 4 + GlyfFlags.getOffsetToNextComposedGlyf(flags);
	} while (GlyfFlags.hasMoreComposites(flags));
	}

	public boolean isComposite(int indexInOriginal) throws IOException {
	int numberOfContours = in.readTTFShort(tableOffset + mtxTab[indexInOriginal].getOffset());
	return numberOfContours < 0;
	}

	/**
	* Reads a composite glyph at a given index and retrieves all the glyph indices of contingent
	* composed glyphs.
	*
	* @param indexInOriginal the glyph index of the composite glyph
	* @return the set of glyph indices this glyph composes
	* @throws IOException an I/O error
	*/
	public Set<Integer> retrieveComposedGlyphs(int indexInOriginal)
	throws IOException {
	Set<Integer> composedGlyphs = new HashSet<Integer>();
	long offset = tableOffset + mtxTab[indexInOriginal].getOffset() + 10;
	int flags = 0;
	do {
	flags = in.readTTFUShort(offset);
	composedGlyphs.add(in.readTTFUShort(offset + 2));
	offset += 4 + GlyfFlags.getOffsetToNextComposedGlyf(flags);
	} while (GlyfFlags.hasMoreComposites(flags));

	return composedGlyphs;
	}
	}