Adding advanced typography capability #297

openpdf/pom.xml

@@ -47,14 +47,24 @@
             <version>${imageio-tiff.version}</version>
             <optional>true</optional>
         </dependency>
-
+        <dependency>
+            <groupId>org.apache.xmlgraphics</groupId>
+            <artifactId>fop</artifactId>
+            <version>${fop.version}</version>
+            <optional>true</optional>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.xmlgraphics</groupId>
+            <artifactId>xmlgraphics-commons</artifactId>
+            <version>${fop.version}</version>
+            <optional>true</optional>
+        </dependency>
         <dependency>
             <groupId>org.hamcrest</groupId>
             <artifactId>hamcrest-core</artifactId>
             <version>${hamcrest.version}</version>
             <scope>test</scope>
         </dependency>
-
     </dependencies>
 
     <build>

openpdf/src/main/java/com/lowagie/text/pdf/FontDetails.java

@@ -211,29 +211,19 @@ byte[] convertToBytes(String text) {
                             longTag.put(metrics[0], new int[]{metrics[0], metrics[1], ttu.getUnicodeDifferences(b[k] & 0xff)});
                             glyph[i++] = (char)metrics[0];
                         }
+                        String s = new String(glyph, 0, i);
+                        b = s.getBytes(CJKFont.CJK_ENCODING);
+
                     }
                     else {
-                        for (int k = 0; k < len; ++k) {
-                            int val;
-                            if (Utilities.isSurrogatePair(text, k)) {
-                                val = Utilities.convertToUtf32(text, k);
-                                k++;
-                            }
-                            else {
-                                val = text.charAt(k);
-                            }
-                            metrics = ttu.getMetricsTT(val);
-                            if (metrics == null)
-                                continue;
-                            int m0 = metrics[0];
-                            Integer gl = m0;
-                            if (!longTag.containsKey(gl))
-                                longTag.put(gl, new int[]{m0, metrics[1], val});
-                            glyph[i++] = (char)m0;
+                        String fileName = ((TrueTypeFontUnicode)getBaseFont()).fileName;
+                        if (FopGlyphProcessor.isFopSupported() && (fileName!=null && fileName.length()>0 
+                                                                   &&( fileName.contains(".ttf") || fileName.contains(".TTF")))){
+                            return FopGlyphProcessor.convertToBytesWithGlyphs(ttu,text,fileName,longTag);
+                        }else {
+                            return convertToBytesWithGlyphs(text);
                         }
                     }
-                    String s = new String(glyph, 0, i);
-                    b = s.getBytes(CJKFont.CJK_ENCODING);
                 }
                 catch (UnsupportedEncodingException e) {
                     throw new ExceptionConverter(e);
@@ -243,7 +233,34 @@ byte[] convertToBytes(String text) {
         }
         return b;
     }
-
+
+    private byte[] convertToBytesWithGlyphs(String text) throws UnsupportedEncodingException {
+        int len = text.length();
+        int[] metrics = null;
+        char[] glyph = new char[len];
+        int i = 0;
+        for (int k = 0; k < len; ++k) {
+            int val;
+            if (Utilities.isSurrogatePair(text, k)) {
+                val = Utilities.convertToUtf32(text, k);
+                k++;
+            }
+            else {
+                val = text.charAt(k);
+            }
+            metrics = ttu.getMetricsTT(val);
+            if (metrics == null)
+                continue;
+            int m0 = metrics[0];
+            Integer gl = m0;
+            if (!longTag.containsKey(gl))
+                longTag.put(gl, new int[]{m0, metrics[1], val});
+            glyph[i++] = (char)m0;
+        }
+        String s = new String(glyph, 0, i);
+        return s.getBytes(CJKFont.CJK_ENCODING);
+    }
+
     byte[] convertToBytes(GlyphVector glyphVector) {
         if (fontType != BaseFont.FONT_TYPE_TTUNI || symbolic) {
             throw new UnsupportedOperationException("Only supported for True Type Unicode fonts");

openpdf/src/main/java/com/lowagie/text/pdf/FopGlyphProcessor.java

@@ -0,0 +1,69 @@
+package com.lowagie.text.pdf;
+
+import java.io.UnsupportedEncodingException;
+import java.nio.IntBuffer;
+import java.util.Map;
+
+import org.apache.fop.complexscripts.fonts.GlyphSubstitutionTable;
+import org.apache.fop.complexscripts.util.CharScript;
+import org.apache.fop.complexscripts.util.GlyphSequence;
+import org.apache.fop.fonts.truetype.TTFFile;
+
+/**
+ * Utilizing Fop advanced typography capabilities for TrueType fonts.
+ * @author  Gajendra kumar ([email protected])
+ */
+public class FopGlyphProcessor {
+
+    private static boolean isFopSupported = false;
+
+    static {
+        try {
+            Class.forName("org.apache.fop.complexscripts.util.GlyphSequence");
+            isFopSupported = true;
+        } catch (ClassNotFoundException e) {
+            isFopSupported = false;
+        }
+    }
+
+    public static boolean isFopSupported(){
+        return isFopSupported;
+    }
+
+    public static byte[] convertToBytesWithGlyphs(BaseFont font, String text, String fileName,
+                                                  Map<Integer, int[]> longTag) throws UnsupportedEncodingException {
+        TrueTypeFontUnicode ttu = (TrueTypeFontUnicode)font;
+        IntBuffer charBuffer = IntBuffer.allocate(text.length());
+        IntBuffer ghyphBuffer = IntBuffer.allocate(text.length());
+        for (char c : text.toCharArray()) {
+            charBuffer.put(c);
+            int[] metrics = ttu.getMetricsTT(c);
+            ghyphBuffer.put(metrics[0]);
+        }
+
+        GlyphSequence glyphSequence = new GlyphSequence(charBuffer, ghyphBuffer, null);
+        TTFFile ttf = TTFCache.getTTFFile(fileName);
+        GlyphSubstitutionTable gsubTable = ttf.getGSUB();
+        if (gsubTable != null) {
+            String script = CharScript.scriptTagFromCode(CharScript.dominantScript(text));
+            String language = "dflt";
+            if ("zyyy".equals(script) || "auto".equals(script)) {
+                script = "*";
+            }
+            glyphSequence = gsubTable.substitute(glyphSequence, script, language);
+        }
+        int[] processedChars = glyphSequence.getGlyphs().array();
+        char[] charEncodedGlyphCodes = new char[processedChars.length];
+
+        for (int i = 0; i < processedChars.length; i++) {
+            charEncodedGlyphCodes[i] = (char) processedChars[i];
+            Integer glyphCode = processedChars[i];
+            if (!longTag.containsKey(glyphCode)) {
+                longTag.put(glyphCode,
+                        new int[] { processedChars[i], ttu.getGlyphWidth(processedChars[i]), processedChars[i] });
+            }
+        }
+        return new String(charEncodedGlyphCodes).getBytes(CJKFont.CJK_ENCODING);
+    }
+
+}

openpdf/src/main/java/com/lowagie/text/pdf/TTFCache.java

@@ -0,0 +1,59 @@
+package com.lowagie.text.pdf;
+
+import com.lowagie.text.ExceptionConverter;
+import org.apache.fop.fonts.apps.TTFReader;
+import org.apache.fop.fonts.truetype.FontFileReader;
+import org.apache.fop.fonts.truetype.TTFFile;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ *
+ *
+ * @author  Gajendra kumar ([email protected])
+ */
+public class TTFCache {
+
+    private static Map<String,TTFFile> ttfFileMap =new ConcurrentHashMap<>();
+
+    public static TTFFile getTTFFile(String fileName) {
+
+        if (ttfFileMap.containsKey(fileName)){
+            return ttfFileMap.get(fileName);
+        }
+        TTFReader app = new TTFReader();
+        TTFFile ttf = null;
+        try {
+            ttf = loadTTF(app,fileName);
+            ttfFileMap.put(fileName,ttf);
+            return ttf;
+        } catch (IOException e) {
+            throw new ExceptionConverter(e);
+        }
+    }
+
+    private static TTFFile loadTTF(TTFReader app, String fileName) throws IOException{
+
+        try {
+            return app.loadTTF(fileName, null, true, true);
+        } catch (IOException e) {
+            TTFFile ttfFile = new TTFFile(true, true);
+            InputStream stream = BaseFont.getResourceStream(fileName, null);
+            try {
+                FontFileReader reader = new FontFileReader(stream);
+                String fontName = null;
+                ttfFile.readFont(reader, fontName);
+            } finally {
+                stream.close();
+            }
+            if (ttfFile.isCFF()) {
+                throw new UnsupportedOperationException(
+                        "OpenType fonts with CFF data are not supported, yet");
+            }
+            return ttfFile;
+        }
+    }
+}

openpdf/src/test/java/com/lowagie/text/pdf/fonts/AdvanceTypographyTest.java

@@ -0,0 +1,33 @@
+package com.lowagie.text.pdf.fonts;
+
+import com.lowagie.text.pdf.BaseFont;
+import com.lowagie.text.pdf.FopGlyphProcessor;
+import org.junit.jupiter.api.Test;
+
+import java.util.HashMap;
+
+import static org.junit.jupiter.api.Assertions.assertArrayEquals;
+
+/**
+ *
+ * @author  Gajendra kumar ([email protected])
+ */
+public class AdvanceTypographyTest {
+
+    /**
+     * Without ghyph substitution out will be {660,666,676,1143,656,1130}, which is no correct
+     * FopGlyphProcessor performs ghyph substitution to correct the output
+     * @throws Exception
+     */
+    @Test
+    public void testTypographySubstitution() throws Exception{
+        char[] expectedOutput = {660,666,911,656,1130};
+        byte[] processedContent = FopGlyphProcessor.convertToBytesWithGlyphs(
+                BaseFont.createFont("fonts/jaldi/Jaldi-Regular.ttf", BaseFont.IDENTITY_H, false)
+                , "नमस्ते", "fonts/jaldi/Jaldi-Regular.ttf", new HashMap<>());
+        String str = new String(processedContent, "UnicodeBigUnmarked");
+
+        assertArrayEquals(expectedOutput,str.toCharArray());
+    }
+
+}

openpdf/src/test/resources/fonts/jaldi/OFL.txt

@@ -0,0 +1,94 @@
+Copyright (c) 2012-2015, Omnibus-Type (www.omnibus-type.com|[email protected])
+
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+This license is copied below, and is also available with a FAQ at:
+http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.

pom.xml

@@ -58,6 +58,7 @@
         <maven.surefire.plugin.version>2.22.1</maven.surefire.plugin.version>
         <maven.test.failure.ignore>false</maven.test.failure.ignore>
         <mockito.version>2.25.1</mockito.version>
+        <fop.version>2.3</fop.version>
     </properties>