Changeset 211

Timestamp:

03/21/08 01:12:13 (4 years ago)

Author:

jharrop

Message:

Support for reading a .TTC - necessary to handle Microsoft Cambria font.

Location:

trunk/docx4j

Files:

• lib/fop-fonts.jar (modified) (previous)
• src/main/java/org/docx4j/fonts/Substituter.java (modified) (4 diffs)
• src/main/resources/fop-fonts.patch (modified) (16 diffs)
• src/main/resources/log4j.xml (modified) (2 diffs)

trunk/docx4j/src/main/java/org/docx4j/fonts/Substituter.java

@@ -64 +64 @@
         /*
          * TODO
-         * - handle Cambria & Cambria Math TTC
+         * - handle Cambria & Cambria Math TTC; currently org.apache.fop.fonts.autodetect.FontFileFinder 
+         *   says "TODO Add *.ttc when support for it has been added to the auto-detection mech."; we
+         *   need that first.
+         *   
          * - Re-enable font cache
          * 
@@ -195 +198 @@
         FontFileFinder fontFileFinder = new FontFileFinder();
         
-        // Automagically finds a list of font files on local system
-        // based on os.name
-        List fontFileList = fontFileFinder.find();                
-        for (Iterator iter = fontFileList.iterator(); iter.hasNext();) {
-            URL fontUrl = (URL)iter.next();
-            // parse font to ascertain font info
-            FontInfoFinder finder = new FontInfoFinder();
-            setupPhysicalFont(fontResolver, fontUrl, finder);
-        }
+//        // Automagically finds a list of font files on local system
+//        // based on os.name
+//        List fontFileList = fontFileFinder.find();                
+//        for (Iterator iter = fontFileList.iterator(); iter.hasNext();) {
+//            URL fontUrl = (URL)iter.next();
+//            // parse font to ascertain font info
+//            FontInfoFinder finder = new FontInfoFinder();
+//            setupPhysicalFont(fontResolver, fontUrl, finder);
+//        }
 
         // Add fonts from our Temporary Embedded Fonts dir
-        fontFileList = fontFileFinder.find( ObfuscatedFontPart.getTemporaryEmbeddedFontsDir() );
+        List fontFileList = fontFileFinder.find( ObfuscatedFontPart.getTemporaryEmbeddedFontsDir() );
         for (Iterator iter = fontFileList.iterator(); iter.hasNext();) {
             URL fontUrl = (URL)iter.next();
@@ -225 +228 @@
          * @param fontResolver
          * @param fontUrl
-         * @param finder
+         * @param fontInfoFinder
          */
         public static void setupPhysicalFont(FontResolver fontResolver,
-                        URL fontUrl, FontInfoFinder finder) {
-                EmbedFontInfo fontInfo = finder.find(fontUrl, fontResolver, fontCache);
-                
-                
-                if (fontInfo == null) {
-                        return;
-                }
-                 if (!fontInfo.isEmbeddable() ) {                                       
-//                      log.info(tokens[x] + " is not embeddable; skipping.");
-                         
-                                // NB isEmbeddable() only exists in our patched FOP
-                        
-                                /*
-                                 * No point looking at this font, since if we tried to use it,
-                                 * later, we'd get:
-                                 *  
-                                 * com.lowagie.text.DocumentException: file:/usr/share/fonts/truetype/ttf-tamil-fonts/lohit_ta.ttf cannot be embedded due to licensing restrictions.
-                                        at com.lowagie.text.pdf.TrueTypeFont.<init>(TrueTypeFont.java:364)
-                                        at com.lowagie.text.pdf.TrueTypeFont.<init>(TrueTypeFont.java:335)
-                                        at com.lowagie.text.pdf.BaseFont.createFont(BaseFont.java:399)
-                                        at com.lowagie.text.pdf.BaseFont.createFont(BaseFont.java:345)
-                                        at org.xhtmlrenderer.pdf.ITextFontResolver.addFont(ITextFontResolver.java:164)
-                                        
-                                        will be thrown if os_2.fsType == 2
-                                        
-                                 */
-//                      log.info(physicalFontKey + " is not embeddable; skipping.");
-                         
-                         return;
-                 }
-                        
-                PhysicalFont pf; 
-                
-                for (Iterator iterIn = fontInfo.getFontTriplets().iterator() ; iterIn.hasNext();) {
-                        FontTriplet triplet = (FontTriplet)iterIn.next(); 
-                        // There is one triplet for each of the font family names
-                        // this font has, and we create a PhysicalFont object 
-                        // for each of them.  For our purposes though, each of
-                        // these physical font objects contains the same info
-                
-                String lower = fontInfo.getEmbedFile().toLowerCase();
-                                        
-                pf = null;
-                // xhtmlrenderer's org.xhtmlrenderer.pdf.ITextFontResolver.addFont
-                // can handle
-                // .otf, .ttf, .ttc, .pfb
-                if (lower.endsWith(".otf") || lower.endsWith(".ttf")) {
-                        pf = new PhysicalFont(fontInfo);
-                } else if (lower.endsWith(".pfb") ) {
-                        // See whether we have everything org.xhtmlrenderer.pdf.ITextFontResolver.addFont
-                        // will need - for a .pfb file, it needs a corresponding .afm or .pfm
-                                String afm = FontUtils.pathFromURL(lower);
-                                afm = afm.substring(0, afm.length()-4 ) + ".afm";  // drop the 'file:'
-                                //log.debug("Looking for: " + afm);                                     
-                                File f = new File(afm);
-                        if (f.exists()) {                               
+                        URL fontUrl, FontInfoFinder fontInfoFinder) {
+                
+                List<EmbedFontInfo> embedFontInfoList = fontInfoFinder.find(fontUrl, fontResolver, fontCache);          
+                
+                for ( EmbedFontInfo fontInfo : embedFontInfoList ) {
+                        
+                        
+                        if (fontInfo == null) {
+                                return;
+                        }
+                         if (!fontInfo.isEmbeddable() ) {                                       
+        //                      log.info(tokens[x] + " is not embeddable; skipping.");
+                                 
+                                        // NB isEmbeddable() only exists in our patched FOP
+                                
+                                        /*
+                                         * No point looking at this font, since if we tried to use it,
+                                         * later, we'd get:
+                                         *  
+                                         * com.lowagie.text.DocumentException: file:/usr/share/fonts/truetype/ttf-tamil-fonts/lohit_ta.ttf cannot be embedded due to licensing restrictions.
+                                                at com.lowagie.text.pdf.TrueTypeFont.<init>(TrueTypeFont.java:364)
+                                                at com.lowagie.text.pdf.TrueTypeFont.<init>(TrueTypeFont.java:335)
+                                                at com.lowagie.text.pdf.BaseFont.createFont(BaseFont.java:399)
+                                                at com.lowagie.text.pdf.BaseFont.createFont(BaseFont.java:345)
+                                                at org.xhtmlrenderer.pdf.ITextFontResolver.addFont(ITextFontResolver.java:164)
+                                                
+                                                will be thrown if os_2.fsType == 2
+                                                
+                                         */
+        //                      log.info(physicalFontKey + " is not embeddable; skipping.");
+                                 
+                                 return;
+                         }
+                                
+                        PhysicalFont pf; 
+                        
+                        for (Iterator iterIn = fontInfo.getFontTriplets().iterator() ; iterIn.hasNext();) {
+                                FontTriplet triplet = (FontTriplet)iterIn.next(); 
+                                // There is one triplet for each of the font family names
+                                // this font has, and we create a PhysicalFont object 
+                                // for each of them.  For our purposes though, each of
+                                // these physical font objects contains the same info
+                        
+                        String lower = fontInfo.getEmbedFile().toLowerCase();
+                                                
+                        pf = null;
+                        // xhtmlrenderer's org.xhtmlrenderer.pdf.ITextFontResolver.addFont
+                        // can handle
+                        // .otf, .ttf, .ttc, .pfb
+                        if (lower.endsWith(".otf") || lower.endsWith(".ttf") || lower.endsWith(".ttc") ) {
                                 pf = new PhysicalFont(fontInfo);
-                        } else {
-                                // Should we be doing afm first, or pfm?
-                                        String pfm = FontUtils.pathFromURL(lower);
-                                        pfm = pfm.substring(0, pfm.length()-4 ) + ".pfm";  // drop the 'file:'
-                                        //log.debug("Looking for: " + pfm);
-                                        f = new File(pfm);
+                        } else if (lower.endsWith(".pfb") ) {
+                                // See whether we have everything org.xhtmlrenderer.pdf.ITextFontResolver.addFont
+                                // will need - for a .pfb file, it needs a corresponding .afm or .pfm
+                                        String afm = FontUtils.pathFromURL(lower);
+                                        afm = afm.substring(0, afm.length()-4 ) + ".afm";  // drop the 'file:'
+                                        //log.debug("Looking for: " + afm);                                     
+                                        File f = new File(afm);
                                 if (f.exists()) {                               
                                         pf = new PhysicalFont(fontInfo);
                                 } else {
-                                        log.warn("Skipping " + triplet.getName() + "; couldn't find .afm or .pfm for : " + fontInfo.getEmbedFile());                                                                                            
+                                        // Should we be doing afm first, or pfm?
+                                                String pfm = FontUtils.pathFromURL(lower);
+                                                pfm = pfm.substring(0, pfm.length()-4 ) + ".pfm";  // drop the 'file:'
+                                                //log.debug("Looking for: " + pfm);
+                                                f = new File(pfm);
+                                        if (f.exists()) {                               
+                                                pf = new PhysicalFont(fontInfo);
+                                        } else {
+                                                log.warn("Skipping " + triplet.getName() + "; couldn't find .afm or .pfm for : " + fontInfo.getEmbedFile());                                                                                            
+                                        }
                                 }
+                        } else {                        
+                                log.warn("Skipping " + triplet.getName() + "; unsupported type: " + fontInfo.getEmbedFile());                                           
                         }
-                } else {                        
-                        log.warn("Skipping " + triplet.getName() + "; unsupported type: " + fontInfo.getEmbedFile());                                           
-                }
-                
-                
-                if (pf!=null) {
-                        
-                        // Add it to the map
-                        physicalFontMap.put(pf.getName(), pf);
-                        //log.debug("Added " + pf.getName() + " -> " + pf.getEmbeddedFile());                   
-                        
-                        // Handle the font family bit - this is critical, since
-                        // it is what iText uses
-                        String familyName = triplet.getName();
-                        pf.setFamilyName(familyName);
-                        
-                        PhysicalFontFamily pff;
-                        if (physicalFontFamiliesMap.get(familyName)==null) {
-                                pff = new PhysicalFontFamily(familyName);
-                                physicalFontFamiliesMap.put(familyName, pff);
-                        } else {
-                                pff = physicalFontFamiliesMap.get(familyName);
-                        }
-                        pff.addFont(pf);
-                        
-                }
-                }               
+                        
+                        
+                        if (pf!=null) {
+                                
+                                // Add it to the map
+                                physicalFontMap.put(pf.getName(), pf);
+                                //log.debug("Added " + pf.getName() + " -> " + pf.getEmbeddedFile());                   
+                                
+                                // Handle the font family bit - this is critical, since
+                                // it is what iText uses
+                                String familyName = triplet.getName();
+                                pf.setFamilyName(familyName);
+                                
+                                PhysicalFontFamily pff;
+                                if (physicalFontFamiliesMap.get(familyName)==null) {
+                                        pff = new PhysicalFontFamily(familyName);
+                                        physicalFontFamiliesMap.put(familyName, pff);
+                                } else {
+                                        pff = physicalFontFamiliesMap.get(familyName);
+                                }
+                                pff.addFont(pf);
+                                
+                        }
+                        }               
+                }
         }
         
@@ -961 +968 @@
         public static void main(String[] args) throws Exception {
 
-                //String inputfilepath = "/home/jharrop/workspace200711/docx4j-001/sample-docs/Word2007-fonts.docx";
-                String inputfilepath = "C:\\Users\\jharrop\\workspace\\docx4j\\sample-docs\\Word2007-fonts.docx";
+                String inputfilepath = "/home/jharrop/workspace200711/docx4j-001/sample-docs/Word2007-fonts.docx";
+                //String inputfilepath = "C:\\Users\\jharrop\\workspace\\docx4j\\sample-docs\\Word2007-fonts.docx";
                 //String inputfilepath = "/home/jharrop/workspace200711/docx4j-001/sample-docs/fonts-modesOfApplication.docx";
                 //String inputfilepath = "/home/jharrop/workspace200711/docx4all/sample-docs/TargetFeatureSet.docx"; //docx4all-fonts.docx";

trunk/docx4j/src/main/resources/fop-fonts.patch

@@ +1 @@
+Index: /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/autodetect/FontFileFinder.java
+===================================================================
+--- /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/autodetect/FontFileFinder.java      (revision 631408)
++++ /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/autodetect/FontFileFinder.java      (working copy)
+@@ -78,7 +78,7 @@
+     protected static IOFileFilter getFileFilter() {
+         return FileFilterUtils.andFileFilter(
+                 FileFilterUtils.fileFileFilter(),
+-                new WildcardFileFilter(new String[] {"*.ttf", "*.otf", "*.pfb"}, IOCase.INSENSITIVE)
++                new WildcardFileFilter(new String[] {"*.ttf", "*.otf", "*.pfb", "*.ttc"}, IOCase.INSENSITIVE)
+                 //TODO Add *.ttc when support for it has been added to the auto-detection mech.
+         );
+     }
 Index: /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/autodetect/FontInfoFinder.java
 ===================================================================
 --- /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/autodetect/FontInfoFinder.java      (revision 631408)
 +++ /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/autodetect/FontInfoFinder.java      (working copy)
-@@ -62,11 +62,47 @@
+@@ -20,8 +20,10 @@
+ package org.apache.fop.fonts.autodetect;
+ 
+ import java.io.IOException;
++import java.io.InputStream;
+ import java.net.URL;
+ import java.net.URLConnection;
++import java.util.ArrayList;
+ import java.util.Collection;
+ import java.util.Iterator;
+ import java.util.List;
+@@ -41,6 +43,9 @@
+ import org.apache.fop.fonts.FontResolver;
+ import org.apache.fop.fonts.FontTriplet;
+ import org.apache.fop.fonts.FontUtil;
++import org.apache.fop.fonts.truetype.FontFileReader;
++import org.apache.fop.fonts.truetype.TTFFile;
++import org.apache.fop.fonts.truetype.TTFFontLoader;
+ 
+ /**
+  * Attempts to determine correct FontInfo
+@@ -62,11 +67,47 @@
              log.trace("Font: " + customFont.getFullName() 
                      + ", family: " + customFont.getFamilyNames() 
@@ -52 +86 @@
          String fullName = stripQuotes(customFont.getFullName());
          String searchName = fullName.toLowerCase();
-@@ -81,9 +117,10 @@
+@@ -81,9 +122,10 @@
          //Full Name usually includes style/weight info so don't use these traits
          //If we still want to use these traits, we have to make FontInfo.fontLookup() smarter
@@ -66 +100 @@
          Iterator iter = familyNames.iterator();
          while (iter.hasNext()) {
-@@ -133,6 +170,9 @@
+@@ -133,6 +175,9 @@
          embedUrl = fontUrl.toExternalForm();
          EmbedFontInfo fontInfo = new EmbedFontInfo(null, customFont.isKerningEnabled(),
@@ -76 +110 @@
              fontCache.addFont(fontInfo);
          }
+@@ -145,12 +190,18 @@
+      * @param fontUrl font URL. Assumed to be local.
+      * @param resolver font resolver used to resolve font
+      * @param fontCache font cache (may be null)
+-     * @return newly created embed font info
++     * @return list of newly created embed font info.  Generally, this list
++     *         will have only one entry, unless the fontUrl is a TTC
+      */
+-    public EmbedFontInfo find(URL fontUrl, FontResolver resolver, FontCache fontCache) {
++    public List<EmbedFontInfo> find(URL fontUrl, FontResolver resolver, FontCache fontCache) {
++       
++       List<EmbedFontInfo> embedFontInfoList = new java.util.ArrayList<EmbedFontInfo>();
++       
+         String embedUrl = null;
+         embedUrl = fontUrl.toExternalForm();
+         
++        System.out.println(embedUrl);
++        
+         long fileLastModified = -1;
+         if (fontCache != null) {
+             try {
+@@ -170,7 +221,8 @@
+             if (fontCache.containsFont(embedUrl)) {
+                 CachedFontInfo fontInfo = fontCache.getFont(embedUrl);
+                 if (fontInfo.lastModified() == fileLastModified) {
+-                    return fontInfo;
++                       embedFontInfoList.add(fontInfo);
++                    return embedFontInfoList;
+                 } else {
+                     // out of date cache item
+                     fontCache.removeFont(embedUrl);
+@@ -184,20 +236,75 @@
+             }
+         }
+         
++        
+         // try to determine triplet information from font file
+         CustomFont customFont = null;
+-        try {
+-            customFont = FontLoader.loadFont(fontUrl, resolver);
+-        } catch (Exception e) {
+-            //TODO Too verbose (it's an error but we don't care if some fonts can't be loaded)
+-            if (log.isErrorEnabled()) {
+-                log.error("Unable to load font file: " + embedUrl + ". Reason: " + e.getMessage());
++        
++        if (fontUrl.toExternalForm().endsWith(".ttc")) {
++               
++               // Get a list of the TTC Font names
++               List<String> ttcNames = null;
++               String fontFileURI = fontUrl.toExternalForm().trim();
++               TTFFontLoader ttfLoader = new TTFFontLoader(fontFileURI, resolver);
++            InputStream in = null;             
++            try {
++               in = FontLoader.openFontUri(resolver, fontFileURI);
++                TTFFile ttf = new TTFFile();
++                FontFileReader reader = new FontFileReader(in);
++                ttcNames = ttf.getTTCnames(reader);
++            } catch (Exception e) {
++               log.error(e);
++            } finally {
++                IOUtils.closeQuietly(in);
+             }
+-            if (fontCache != null) {
+-                fontCache.registerFailedFont(embedUrl, fileLastModified);
++               
++               // For each font name ...
++               for (String fontName : ttcNames) {
++
++                       log.debug("Loading " + fontName);
++                   try {
++                       ttfLoader = new TTFFontLoader(fontFileURI, resolver);
++                       ttfLoader.read(fontName);
++                       customFont = ttfLoader.getFont();
++                   } catch (Exception e) {
++                       //TODO Too verbose (it's an error but we don't care if some fonts can't be loaded)
++                       //if (log.isErrorEnabled()) {
++                           log.error("Unable to load font file: " + embedUrl + ". Reason: " + e.getMessage());
++                       //}
++                       if (fontCache != null) {
++                           fontCache.registerFailedFont(embedUrl, fileLastModified);
++                       }
++                       continue;
++                   }
++                   EmbedFontInfo fi = fontInfoFromCustomFont(fontUrl, customFont, fontCache);
++                   if (fi!=null) {
++                       embedFontInfoList.add(fi);
++                   } 
++               }
++               return embedFontInfoList;
++        } else {
++               // The normal case
++            try {
++                customFont = FontLoader.loadFont(fontUrl, resolver);
++            } catch (Exception e) {
++                //TODO Too verbose (it's an error but we don't care if some fonts can't be loaded)
++                //if (log.isErrorEnabled()) {
++                    log.error("Unable to load font file: " + embedUrl + ". Reason: " + e.getMessage());
++                //}
++                if (fontCache != null) {
++                    fontCache.registerFailedFont(embedUrl, fileLastModified);
++                }
++                return null;
+             }
+-            return null;
++            EmbedFontInfo fi = fontInfoFromCustomFont(fontUrl, customFont, fontCache);
++            if (fi!=null) {
++               embedFontInfoList.add(fi);
++                return embedFontInfoList;              
++            } else {
++               return null;
++            }          
+         }
+-        return fontInfoFromCustomFont(fontUrl, customFont, fontCache);     
++        
++
+     }
+ }
 Index: /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/CustomFont.java
 ===================================================================
@@ -150 +301 @@
      /**
       * Main constructor
+Index: /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/FontLoader.java
+===================================================================
+--- /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/FontLoader.java     (revision 631408)
++++ /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/FontLoader.java     (working copy)
+@@ -121,7 +121,7 @@
+      * @throws IOException In case of an I/O error
+      * @throws MalformedURLException If an invalid URL is built
+      */
+-    protected static InputStream openFontUri(FontResolver resolver, String uri) 
++    public static InputStream openFontUri(FontResolver resolver, String uri) 
+                     throws IOException, MalformedURLException {
+         InputStream in = null;
+         if (resolver != null) {
 Index: /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/MultiByteFont.java
 ===================================================================
@@ -192 +356 @@
 --- /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/Panose.java (revision 0)
 +++ /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/Panose.java (revision 0)
-@@ -0,0 +1,391 @@
+@@ -0,0 +1,396 @@
 +/*
 + * Copyright 2006 The FOray Project.
@@ -451 +615 @@
 +               // Already the maximum value - do nothing
 +       } else if (panoseArray[2]<8) {
-+               panoseArray[2]=7; // 8 = bold, but most of the MS ClearType Collection fonts have 7 here.
++               panoseArray[2]=8; 
++               // 8 = bold, and even though most of the MS ClearType Collection fonts have 7 here,
++               // experience (Times New Roman) shows it is better to be on the high side, to stop
++               // this Panose array from being equidistant between the normal weight and the
++               // bold weight.
++               
 +       } else {
 +               // Do nothing, rather than increase the Weight
@@ -467 +636 @@
 +               // Already the maximum value - do nothing
 +       } else if (panoseArray[7]<9) {
-+               panoseArray[7]=9; // Most fonts have 9 or 10 here.
++               panoseArray[7]=10; // Most fonts have 9 or 10 here, so use 10 on the same reasoning as above.
 +       } else {
 +               // Do nothing, rather than increase the Letterform setting 
@@ -588 +757 @@
 --- /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/truetype/TTFFile.java       (revision 631408)
 +++ /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/truetype/TTFFile.java       (working copy)
-@@ -31,6 +31,7 @@
+@@ -30,7 +30,9 @@
+ 
  import org.apache.xmlgraphics.fonts.Glyphs;
  
++import org.apache.fop.fonts.EmbedFontInfo;
  import org.apache.fop.fonts.FontUtil;
 +import org.apache.fop.fonts.Panose;
@@ -596 +767 @@
  /**
   * Reads a TrueType file or a TrueType Collection.
-@@ -48,9 +49,12 @@
+@@ -48,9 +50,12 @@
      public static final boolean TRACE_ENABLED = false;
  
@@ -610 +781 @@
      /**
       * Table directory
-@@ -549,8 +553,10 @@
+@@ -549,8 +554,10 @@
       */
      public String getPostScriptName() {
@@ -621 +792 @@
          }
      }
-@@ -743,6 +749,7 @@
+@@ -743,6 +750,7 @@
       * @return boolean True if it may be embedded
       */
@@ -629 +800 @@
      }
  
-@@ -988,7 +995,10 @@
+@@ -988,7 +996,10 @@
          if (dirTabs.get("OS/2") != null) {
              seekTab(in, "OS/2", 2 * 2);
@@ -640 +811 @@
              if (fsType == 2) {
                  isEmbeddable = false;
-@@ -996,10 +1006,21 @@
+@@ -996,10 +1007,21 @@
                  isEmbeddable = true;
              }
@@ -663 +834 @@
              os2Ascender = in.readTTFShort(); //sTypoAscender
              log.debug("sTypoAscender: " + os2Ascender 
-@@ -1568,4 +1589,8 @@
+@@ -1474,6 +1496,66 @@
+         }
+     }
+ 
++    /**
++     * Return TTC font names
++     * @param in FontFileReader to read from
++     * @return True if not collection or font name present, false otherwise
++     * @throws IOException In case of an I/O problem
++     */
++    public final List<String> getTTCnames(FontFileReader in) throws IOException {
++       
++       List<String> fontNames = new java.util.ArrayList<String>();
++       
++        String tag = in.readTTFString(4);
++
++        if ("ttcf".equals(tag)) {
++            // This is a TrueType Collection
++            in.skip(4);
++
++            // Read directory offsets
++            int numDirectories = (int)in.readTTFULong();
++            // int numDirectories=in.readTTFUShort();
++            long[] dirOffsets = new long[numDirectories];
++            for (int i = 0; i < numDirectories; i++) {
++                dirOffsets[i] = in.readTTFULong();
++            }
++
++            log.info("This is a TrueType collection file with "
++                                   + numDirectories + " fonts");
++            log.info("Containing the following fonts: ");
++            // Read all the directories and name tables to check
++            // If the font exists - this is a bit ugly, but...
++            boolean found = false;
++
++            // Iterate through all name tables even if font
++            // Is found, just to show all the names
++            long dirTabOffset = 0;
++            for (int i = 0; (i < numDirectories); i++) {
++                in.seekSet(dirOffsets[i]);
++                readDirTabs(in);
++
++                readName(in);
++
++                log.info(fullName);
++                fontNames.add(fullName);
++
++                // Reset names
++                notice = "";
++                fullName = "";
++                familyNames.clear();
++                postScriptName = "";
++                subFamilyName = "";
++            }
++
++            in.seekSet(0);
++            return fontNames;
++        } else {
++               log.error("Not a TTC!");
++               return null;
++        }
++    }
++    
++    
+     /*
+      * Helper classes, they are not very efficient, but that really
+      * doesn't matter...
+@@ -1568,4 +1650,8 @@
              ioe.printStackTrace(System.err);
          }
@@ -677 +915 @@
 --- /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/truetype/TTFFontLoader.java (revision 631408)
 +++ /home/jharrop/workspace200711/fop/src/java/org/apache/fop/fonts/truetype/TTFFontLoader.java (working copy)
-@@ -92,6 +92,9 @@
+@@ -51,6 +51,10 @@
+     
+     /** {@inheritDoc} */
+     protected void read() throws IOException {
++        read(null);
++    }
++
++    public void read(String ttcFontName) throws IOException {
+         InputStream in = openFontUri(resolver, this.fontFileURI);
+         try {
+             TTFFile ttf = new TTFFile();
+@@ -55,7 +59,7 @@
+         try {
+             TTFFile ttf = new TTFFile();
+             FontFileReader reader = new FontFileReader(in);
+-            boolean supported = ttf.readFont(reader, null);
++            boolean supported = ttf.readFont(reader, ttcFontName);
+             if (!supported) {
+                 throw new IOException("TrueType font is not supported: " + fontFileURI);
+             }
+@@ -65,7 +69,8 @@
+             IOUtils.closeQuietly(in);
+         }
+     }
+-
++    
++    
+     private void buildFont(TTFFile ttf) {
+         if (ttf.isCFF()) {
+             throw new UnsupportedOperationException(
+@@ -92,6 +97,9 @@
          returnFont.setMissingWidth(0);
          returnFont.setWeight(ttf.getWeightClass());

trunk/docx4j/src/main/resources/log4j.xml

@@ -57 +57 @@
 
     <logger name="org.docx4j.openpackaging.io">
-                <level value="info"/> 
+                <level value="debug"/> 
         </logger>
 
@@ -68 +68 @@
         </logger>
 
+    <logger name="org.docx4j.fonts">
+                <level value="debug"/> 
+        </logger>