Java > Open Source Codes > it > stefanochizzolini > clown > documents > contents > fonts > OpenTypeFont


1 /*
2   Copyright © 2007 Stefano Chizzolini. http://clown.stefanochizzolini.it
3
4   Contributors:
5     * Stefano Chizzolini (original code developer, info@stefanochizzolini.it):
6       contributed code is Copyright © 2007 by Stefano Chizzolini.
7
8   This file should be part of the source code distribution of "PDF Clown library"
9   (the Program): see the accompanying README files for more info.
10
11   This Program is free software; you can redistribute it and/or modify it under
12   the terms of the GNU General Public License as published by the Free Software
13   Foundation; either version 2 of the License, or (at your option) any later version.
14
15   This Program is distributed in the hope that it will be useful, but WITHOUT ANY
16   WARRANTY, either expressed or implied; without even the implied warranty of
17   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the License for more details.
18
19   You should have received a copy of the GNU General Public License along with this
20   Program (see README files); if not, go to the GNU website (http://www.gnu.org/).
21
22   Redistribution and use, with or without modification, are permitted provided that such
23   redistributions retain the above copyright notice, license and disclaimer, along with
24   this list of conditions.
25 */
26
27 package it.stefanochizzolini.clown.documents.contents.fonts;
28
29 import it.stefanochizzolini.clown.bytes.Buffer;
30 import it.stefanochizzolini.clown.bytes.IInputStream;
31 import it.stefanochizzolini.clown.documents.Document;
32 import it.stefanochizzolini.clown.objects.PdfArray;
33 import it.stefanochizzolini.clown.objects.PdfDictionary;
34 import it.stefanochizzolini.clown.objects.PdfDirectObject;
35 import it.stefanochizzolini.clown.objects.PdfIndirectObject;
36 import it.stefanochizzolini.clown.objects.PdfInteger;
37 import it.stefanochizzolini.clown.objects.PdfName;
38 import it.stefanochizzolini.clown.objects.PdfReal;
39 import it.stefanochizzolini.clown.objects.PdfRectangle;
40 import it.stefanochizzolini.clown.objects.PdfStream;
41 import it.stefanochizzolini.clown.util.NotImplementedException;
42
43 import java.util.EnumSet ;
44 import java.util.Hashtable ;
45
46 /**
47   OpenType font [PDF:1.6:5;OTF:1.4].
48 */
49 public class OpenTypeFont
50   extends Font
51 {
52   // <class>
53 // <classes>
54 /**
55     Font metrics.
56   */
57   private static final class FontMetrics
58   {
59     /**
60       Whether the encoding is custom (symbolic font).
61     */
62     public boolean isCustomEncoding;
63     /**
64       Unit normalization coefficient.
65     */
66     public float unitNorm;
67     /*
68       Font Header ('head' table).
69     */
70     public int flags; // USHORT.
71 public int unitsPerEm; // USHORT.
72 public short xMin;
73     public short yMin;
74     public short xMax;
75     public short yMax;
76     public int macStyle; // USHORT.
77 /*
78       Horizontal Header ('hhea' table).
79     */
80     public short ascender;
81     public short descender;
82     public short lineGap;
83     public int advanceWidthMax; // UFWORD.
84 public short minLeftSideBearing;
85     public short minRightSideBearing;
86     public short xMaxExtent;
87     public short caretSlopeRise;
88     public short caretSlopeRun;
89     public int numberOfHMetrics; // USHORT.
90 /*
91       OS/2 table ('OS/2' table).
92     */
93     public short sTypoAscender;
94     public short sTypoDescender;
95     public short sTypoLineGap;
96     public short sxHeight;
97     public short sCapHeight;
98     /*
99       PostScript table ('post' table).
100     */
101     public float italicAngle;
102     public short underlinePosition;
103     public short underlineThickness;
104     public boolean isFixedPitch;
105   }
106
107   /**
108     Font data parser.
109   */
110   private final class Parser
111   {
112     private static final String Encoding_Latin1 = "ISO-8859-1";
113     private static final String Encoding_Unicode = "UTF-16";
114     private static final int MicrosoftLanguage_UsEnglish = 0x409;
115     private static final int NameID_FontPostscriptName = 6;
116     private static final int PlatformID_Microsoft = 3;
117
118     public String fontName;
119     public PdfName subType;
120
121     private IInputStream fontData;
122
123     private Hashtable <String ,Integer > tableOffsets;
124
125     private Parser(
126       IInputStream fontData
127       )
128     {
129       this.fontData = fontData;
130
131       load();
132     }
133
134     /**
135       Loads the font data.
136     */
137     private void load(
138       )
139     {
140       OpenTypeFont.this.metrics = new FontMetrics();
141
142       try
143       {
144         // 1. Offset Table.
145 // Which font file format ('sfnt') version?
146 switch(fontData.readInt())
147         {
148           case(0x00010000): // TrueType.
149 this.subType = PdfName.TrueType;
150             break;
151           case(0x4F54544F): // CFF (Type 1).
152 this.subType = PdfName.Type1;
153             break;
154           default:
155             throw new FontFileFormatException("Not a valid OpenType font file.");
156         }
157         // Get the number of tables!
158 int tableCount = fontData.readUnsignedShort();
159         this.tableOffsets = new Hashtable <String ,Integer >(tableCount);
160
161         // Skip to the beginning of the table directory!
162 fontData.skip(6);
163         // 2. Table Directory.
164 // Collecting the table offsets...
165 for(
166           int index = 0;
167           index < tableCount;
168           index++
169           )
170         {
171           // Get the table tag!
172 String tag = readString_ascii(4);
173           // Skip to the table offset!
174 fontData.skip(4);
175           // Get the table offset!
176 int offset = fontData.readInt();
177           // Collect the table offset!
178 tableOffsets.put(tag,offset);
179
180           // Skip to the next entry!
181 fontData.skip(4);
182         }
183
184         this.fontName = load_getName(NameID_FontPostscriptName);
185
186         load_tables();
187         load_cMap();
188         load_glyphWidths();
189         load_glyphKerning();
190       }
191       catch(Exception e)
192       {throw new RuntimeException (e);}
193     }
194
195     /**
196       Loads the character to glyph index mapping table.
197     */
198     private void load_cMap(
199       )
200       throws FontFileFormatException
201     {
202       /*
203         NOTE: A 'cmap' table may contain one or more subtables that represent multiple encodings
204         intended for use on different platforms (such as Mac OS and Windows).
205         Each subtable is identified by the two numbers, such as (3,1), that represent a combination
206         of a platform ID and a platform-specific encoding ID, respectively.
207         A symbolic font (used to display glyphs that do not use standard encodings, i.e. neither
208         MacRomanEncoding nor WinAnsiEncoding) program's "cmap" table should contain a (1,0) subtable.
209         It may also contain a (3,0) subtable; if present, this subtable should map from character
210         codes in the range 0xF000 to 0xF0FF by prepending the single-byte codes in the (1,0) subtable
211         with 0xF0 and mapping to the corresponding glyph descriptions.
212       */
213       // Character To Glyph Index Mapping Table ('cmap' table).
214 // Retrieve the location info!
215 int tableOffset = tableOffsets.get("cmap");
216       if(tableOffset == 0)
217         throw new FontFileFormatException("'cmap' table does NOT exist.");
218
219       int map10Offset = 0;
220       int map31Offset = 0;
221       try
222       {
223         // Header.
224 // Go to the number of tables!
225 fontData.seek(tableOffset + 2);
226         int tableCount = fontData.readUnsignedShort();
227
228         // Encoding records.
229 /*
230           NOTE: Symbolic fonts use specific (non-standard, i.e. neither Unicode nor platform-standard)
231           font encodings.
232         */
233         metrics.isCustomEncoding = false;
234         // Iterating through the entries...
235 for(
236           int tableIndex = 0;
237           tableIndex < tableCount;
238           tableIndex++
239           )
240         {
241           // Platform ID.
242 int platformID = fontData.readUnsignedShort();
243           // Encoding ID.
244 int encodingID = fontData.readUnsignedShort();
245           // Subtable offset.
246 int offset = fontData.readInt();
247     //TODO:DEBUG verify whether to use mac 1,0 or 3,0 tables for symbolic fonts!!!
248 switch(platformID)
249           {
250             case 1: // Macintosh.
251 if(encodingID == 0)
252                 map10Offset = offset;
253               break;
254             case PlatformID_Microsoft:
255               /*
256                 NOTE: When building a symbol font for Windows, the platform ID should be 3 and the
257                 encoding ID should be 0.
258                 When building a Unicode font for Windows, the platform ID should be 3 and the
259                 encoding ID should be 1.
260               */
261               switch(encodingID)
262               {
263                 case 0: // Symbolic font.
264 metrics.isCustomEncoding = true;
265                   break;
266                 case 1: // Nonsymbolic font.
267 map31Offset = offset;
268                   break;
269               }
270               break;
271           }
272         }
273       }
274       catch(Exception e)
275       {throw new RuntimeException (e);}
276
277       // Is it symbolic?
278 if(metrics.isCustomEncoding) // Symbolic.
279 {
280         // Does map(1,0) exist?
281 if(map10Offset > 0)
282         {
283           // Go to the beginning of the subtable!
284 fontData.seek(tableOffset + map10Offset);
285         }
286         else
287         {throw new FontFileFormatException("(1,0) symbolic table does NOT exist.");}
288       }
289       else // Nonsymbolic.
290 {
291         // Does map(3,1) exist?
292 if(map31Offset > 0)
293         {
294           // Go to the beginning of the subtable!
295 fontData.seek(tableOffset + map31Offset);
296         }
297         else
298         {throw new FontFileFormatException("(3,1) nonsymbolic table does NOT exist.");}
299       }
300
301       int format;
302       try
303       {format = fontData.readUnsignedShort();}
304       catch(Exception e)
305       {throw new RuntimeException (e);}
306       // Which cmap table format?
307 switch(format)
308       {
309         case 0: // Byte encoding table.
310 load_cMap_format0();
311           break;
312         case 4: // Segment mapping to delta values.
313 load_cMap_format4();
314           break;
315         case 6: // Trimmed table mapping.
316 load_cMap_format6();
317           break;
318         default:
319           throw new FontFileFormatException("Format " + format + " cmap table NOT supported.");
320       }
321     }
322
323     /**
324       Loads format-0 cmap subtable (Byte encoding table, i.e. Apple standard
325       character-to-glyph index mapping table).
326       @return Map of character codes to glyph indexes.
327     */
328     private void load_cMap_format0(
329       )
330     {
331       /*
332         NOTE: This is a simple 1-to-1 mapping of character codes to glyph indices.
333         The glyph collection is limited to 256 entries.
334       */
335       OpenTypeFont.this.glyphIndexes = new Hashtable <Integer ,Integer >(256);
336
337       try
338       {
339         // Skip to the mapping array!
340 fontData.skip(4);
341         // Glyph index array.
342 // Iterating through the glyph indexes...
343 for(
344           int code = 0;
345           code < 256;
346           code++
347           )
348         {
349           glyphIndexes.put(
350             code, // Character code.
351 fontData.readUnsignedByte() // Glyph index.
352 );
353         }
354       }
355       catch(Exception e)
356       {throw new RuntimeException (e);}
357     }
358
359     /**
360       Loads format-4 cmap subtable (Segment mapping to delta values, i.e. Microsoft standard
361       character to glyph index mapping table for fonts that support Unicode ranges other than the
362       range [U+D800 - U+DFFF] (defined as Surrogates Area, in Unicode v 3.0)).
363       @return Map of character codes to glyph indexes.
364     */
365     private void load_cMap_format4(
366       )
367     {
368       /*
369         NOTE: This format is used when the character codes for the characters represented by a font
370         fall into several contiguous ranges, possibly with holes in some or all of the ranges (i.e.
371         some of the codes in a range may not have a representation in the font).
372         The format-dependent data is divided into three parts, which must occur in the following
373         order:
374           1. A header gives parameters for an optimized search of the segment list;
375           2. Four parallel arrays (end characters, start characters, deltas and range offsets)
376           describe the segments (one segment for each contiguous range of codes);
377           3. A variable-length array of glyph IDs.
378       */
379       try
380       {
381         // 1. Header.
382 // Get the table length!
383 int tableLength = fontData.readUnsignedShort(); // USHORT.
384
385         // Skip to the segment count!
386 fontData.skip(2);
387         // Get the segment count!
388 int segmentCount = fontData.readUnsignedShort() / 2;
389
390         // 2. Arrays describing the segments.
391 // Skip to the array of end character code for each segment!
392 fontData.skip(6);
393         // End character code for each segment.
394 int[] endCodes = new int[segmentCount]; // USHORT.
395 for(
396           int index = 0;
397           index < segmentCount;
398           index++
399           )
400         {endCodes[index] = fontData.readUnsignedShort();}
401
402         // Skip to the array of start character code for each segment!
403 fontData.skip(2);
404         // Start character code for each segment.
405 int[] startCodes = new int[segmentCount]; // USHORT.
406 for(
407           int index = 0;
408           index < segmentCount;
409           index++
410           )
411         {startCodes[index] = fontData.readUnsignedShort();}
412
413         // Delta for all character codes in segment.
414 short[] deltas = new short[segmentCount];
415         for(
416           int index = 0;
417           index < segmentCount;
418           index++
419           )
420         {deltas[index] = fontData.readShort();}
421
422         // Offsets into glyph index array.
423 int[] rangeOffsets = new int[segmentCount]; // USHORT.
424 for(
425           int index = 0;
426           index < segmentCount;
427           index++
428           )
429         {rangeOffsets[index] = fontData.readUnsignedShort();}
430
431         // 3. Glyph id array.
432 /*
433           NOTE: There's no explicit field defining the array length; it must be inferred from
434           the space left by the known fields.
435         */
436         int glyphIndexCount = tableLength / 2 // Number of 16-bit words inside the table.
437 - 8 // Number of single-word header fields (8 fields: format, length, language, segCountX2, searchRange, entrySelector, rangeShift, reservedPad).
438 - segmentCount * 4; // Number of single-word items in the arrays describing the segments (4 arrays of segmentCount items).
439 int[] glyphIds = new int[glyphIndexCount]; // USHORT.
440 for(
441           int index = 0;
442           index < glyphIds.length;
443           index++
444           )
445         {glyphIds[index] = fontData.readUnsignedShort();}
446
447         OpenTypeFont.this.glyphIndexes = new Hashtable <Integer ,Integer >(glyphIndexCount);
448         // Iterating through the segments...
449 for(
450           int segmentIndex = 0;
451           segmentIndex < segmentCount;
452           segmentIndex++
453           )
454         {
455           int endCode = endCodes[segmentIndex];
456           // Is it NOT the last end character code?
457 /*
458             NOTE: The final segment's endCode MUST be 0xFFFF. This segment need not (but MAY)
459             contain any valid mappings (it can just map the single character code 0xFFFF to
460             missing glyph). However, the segment MUST be present.
461           */
462           if(endCode != 0xFFFF)
463           {endCode++;}
464           // Iterating inside the current segment...
465 for(
466             int code = startCodes[segmentIndex];
467             code < endCode;
468             code++
469             )
470           {
471             int glyphIndex;
472             // Doesn't the mapping of character codes rely on glyph id?
473 if(rangeOffsets[segmentIndex] == 0) // No glyph-id reliance.
474 {
475               /*
476                 NOTE: If the range offset is 0, the delta value is added directly to the character
477                 code to get the corresponding glyph index. The delta arithmetic is modulo 65536.
478               */
479               glyphIndex = (code + deltas[segmentIndex]) & 0xFFFF;
480             }
481             else // Glyph-id reliance.
482 {
483               /*
484                 NOTE: If the range offset is NOT 0, the mapping of character codes relies on glyph
485                 id.
486                 The character code offset from start code is added to the range offset. This sum is
487                 used as an offset from the current location within range offset itself to index out
488                 the correct glyph id. This obscure indexing trick (sic!) works because glyph id
489                 immediately follows range offset in the font file. The C expression that yields the
490                 address to the glyph id is:
491                   *(rangeOffsets[segmentIndex]/2
492                   + (code - startCodes[segmentIndex])
493                   + &idRangeOffset[segmentIndex])
494                 As Java language semantics don't deal directly with pointers, we have to further
495                 exploit such a trick reasoning with 16-bit displacements in order to yield an index
496                 instead of an address (sooo-good!).
497               */
498               // Retrieve the glyph index!
499 int glyphIdIndex = rangeOffsets[segmentIndex] / 2 // 16-bit word range offset.
500 + (code - startCodes[segmentIndex]) // Character code offset from start code.
501 - (segmentCount - segmentIndex); // Physical offset between the offsets into glyph index array and the glyph index array.
502 // Is it a missing glyph?
503 /*
504                 NOTE: If the value obtained from the indexing operation is not 0 (which indicates
505                 missing glyph), deltas[segmentIndex] is added to it to get the glyph index. The delta
506                 arithmetic is modulo 65536.
507               */
508               if(glyphIdIndex == 0) // Missing glyph.
509 {glyphIndex = 0;}
510               else // Available glyph.
511 {glyphIndex = (glyphIds[glyphIdIndex] + deltas[segmentIndex]) & 0xFFFF;}
512             }
513
514             glyphIndexes.put(
515               code, // Character code.
516 glyphIndex // Glyph index.
517 );
518           }
519         }
520       }
521       catch(Exception e)
522       {throw new RuntimeException (e);}
523     }
524
525     /**
526       Loads format-6 cmap subtable (Trimmed table mapping).
527       @return Map of character codes to glyph indexes.
528     */
529     private void load_cMap_format6(
530       )
531     {
532       try
533       {
534         // Skip to the first character code!
535 fontData.skip(4);
536         int firstCode = fontData.readUnsignedShort();
537         int codeCount = fontData.readUnsignedShort();
538         OpenTypeFont.this.glyphIndexes = new Hashtable <Integer ,Integer >(codeCount);
539         for(
540           int code = firstCode,
541             lastCode = firstCode + codeCount;
542           code < lastCode;
543           code++
544           )
545         {
546           glyphIndexes.put(
547             code, // Character code.
548 fontData.readUnsignedShort() // Glyph index.
549 );
550         }
551       }
552       catch(Exception e)
553       {throw new RuntimeException (e);}
554     }
555
556     /**
557       Gets a name.
558       @param id Name identifier.
559     */
560     private String load_getName(
561       int id
562       )
563       throws FontFileFormatException
564     {
565       // Naming Table ('name' table).
566 // Retrieve the location info!
567 int tableOffset = tableOffsets.get("name");
568       if(tableOffset == 0)
569         throw new FontFileFormatException("'name' table does NOT exist.");
570
571       try
572       {
573         // Go to the number of name records!
574 fontData.seek(tableOffset + 2);
575
576         int recordCount = fontData.readUnsignedShort(); // USHORT.
577 int storageOffset = fontData.readUnsignedShort(); // USHORT.
578 // Iterating through the name records...
579 for(
580           int recordIndex = 0;
581           recordIndex < recordCount;
582           recordIndex++
583           )
584         {
585           int platformID = fontData.readUnsignedShort(); // USHORT.
586 // Is it the default platform?
587 if(platformID == PlatformID_Microsoft)
588           {
589             fontData.skip(2);
590             int languageID = fontData.readUnsignedShort(); // USHORT.
591 // Is it the default language?
592 if(languageID == MicrosoftLanguage_UsEnglish)
593             {
594               int nameID = fontData.readUnsignedShort(); // USHORT.
595 // Does the name ID equal the searched one?
596 if(nameID == id)
597               {
598                 int length = fontData.readUnsignedShort(); // USHORT.
599 int offset = fontData.readUnsignedShort(); // USHORT.
600
601                 // Go to the name string!
602 fontData.seek(tableOffset + storageOffset + offset);
603
604                 return readString(length,platformID);
605               }
606               else
607               {fontData.skip(4);}
608             }
609             else
610             {fontData.skip(6);}
611           }
612           else
613           {fontData.skip(10);}
614         }
615
616         return null; // Not found.
617 }
618       catch(Exception e)
619       {throw new RuntimeException (e);}
620     }
621
622     /**
623       Loads the glyph kerning.
624     */
625     private void load_glyphKerning(
626       )
627       throws FontFileFormatException
628     {
629       // Kerning ('kern' table).
630 // Retrieve the location info!
631 int tableOffset;
632       try
633       {tableOffset = tableOffsets.get("kern");}
634       catch(Exception e)
635       {return;}
636
637       try
638       {
639         // Go to the table count!
640 fontData.seek(tableOffset + 2);
641         int subtableCount = fontData.readUnsignedShort(); // USHORT.
642
643         OpenTypeFont.this.glyphKernings = new Hashtable <Integer ,Integer >();
644         int subtableOffset = (int)fontData.getPosition();
645         // Iterating through the subtables...
646 for(
647           int subtableIndex = 0;
648           subtableIndex < subtableCount;
649           subtableIndex++
650           )
651         {
652           // Go to the subtable length!
653 fontData.seek(subtableOffset + 2);
654           // Get the subtable length!
655 int length = fontData.readUnsignedShort(); // USHORT.
656
657           // Get the type of information contained in the subtable!
658 int coverage = fontData.readUnsignedShort(); // USHORT.
659 // Is it a format-0 subtable?
660 /*
661             NOTE: coverage bits 8-15 (format of the subtable) MUST be all zeros
662             (representing format 0).
663           */
664           //
665 if((coverage & 0xff00) == 0x0000)
666           {
667             int pairCount = fontData.readUnsignedShort(); // USHORT.
668
669             // Skip to the beginning of the list!
670 fontData.skip(6);
671             // List of kerning pairs and values.
672 for(
673               int pairIndex = 0;
674               pairIndex < pairCount;
675               pairIndex++
676               )
677             {
678               // Get the glyph index pair (left-hand and right-hand)!
679 int pair = fontData.readInt(); // USHORT USHORT.
680 // Get the normalized kerning value!
681 int value = (int)(fontData.readShort() * metrics.unitNorm);
682
683               glyphKernings.put(pair,value);
684             }
685           }
686
687           subtableOffset += length;
688         }
689       }
690       catch(Exception e)
691       {throw new RuntimeException (e);}
692     }
693
694     /**
695       Loads the glyph widths.
696     */
697     private void load_glyphWidths(
698       )
699       throws FontFileFormatException
700     {
701       // Horizontal Metrics ('hmtx' table).
702 // Retrieve the location info!
703 int tableOffset = tableOffsets.get("hmtx");
704       if(tableOffset == 0)
705         throw new FontFileFormatException("'hmtx' table does NOT exist.");
706
707       try
708       {
709         // Go to the glyph horizontal-metrics entries!
710 fontData.seek(tableOffset);
711         OpenTypeFont.this.glyphWidths = new int[metrics.numberOfHMetrics]; // USHORT.
712 for(
713           int index = 0;
714           index < metrics.numberOfHMetrics;
715           index++
716           )
717         {
718           // Get the glyph advance width!
719 glyphWidths[index] = (int)(fontData.readUnsignedShort() * metrics.unitNorm);
720           // Skip the left side bearing!
721 fontData.skip(2);
722         }
723       }
724       catch(Exception e)
725       {throw new RuntimeException (e);}
726     }
727
728     /**
729       Loads general tables.
730     */
731     private void load_tables(
732       )
733       throws FontFileFormatException
734     {
735       // Font Header ('head' table).
736 // Retrieve the location info!
737 int tableOffset = tableOffsets.get("head");
738       if(tableOffset == 0)
739         throw new FontFileFormatException("'head' table does NOT exist.");
740
741       try
742       {
743         // Go to the font flags!
744 fontData.seek(tableOffset + 16);
745         metrics.flags = fontData.readUnsignedShort();
746         metrics.unitsPerEm = fontData.readUnsignedShort();
747         metrics.unitNorm = 1000f / metrics.unitsPerEm;
748         // Go to the bounding box limits!
749 fontData.skip(16);
750         metrics.xMin = fontData.readShort();
751         metrics.yMin = fontData.readShort();
752         metrics.xMax = fontData.readShort();
753         metrics.yMax = fontData.readShort();
754         metrics.macStyle = fontData.readUnsignedShort();
755       }
756       catch(Exception e)
757       {throw new RuntimeException (e);}
758
759       // Font Header ('head' table).
760 // Retrieve the location info!
761 tableOffset = tableOffsets.get("OS/2");
762       if(tableOffset == 0)
763         throw new FontFileFormatException("'OS/2' table does NOT exist.");
764
765       try
766       {
767         fontData.seek(tableOffset);
768         int version = fontData.readUnsignedShort();
769         // Go to the ascender!
770 fontData.skip(66);
771         metrics.sTypoAscender = fontData.readShort();
772         metrics.sTypoDescender = fontData.readShort();
773         metrics.sTypoLineGap = fontData.readShort();
774         if(version >= 2)
775         {
776           fontData.skip(12);
777           metrics.sxHeight = fontData.readShort();
778           metrics.sCapHeight = fontData.readShort();
779         }
780         else
781         {
782           /*
783             NOTE: These are just rule-of-thumb values, in case the xHeight and CapHeight fields
784             aren't available.
785           */
786           metrics.sxHeight = (short)(.5 * metrics.unitsPerEm);
787           metrics.sCapHeight = (short)(.7 * metrics.unitsPerEm);
788         }
789       }
790       catch(Exception e)
791       {throw new RuntimeException (e);}
792
793       // Horizontal Header ('hhea' table).
794 // Retrieve the location info!
795 tableOffset = tableOffsets.get("hhea");
796       if(tableOffset == 0)
797         throw new FontFileFormatException("'hhea' table does NOT exist.");
798
799       try
800       {
801         // Go to the ascender!
802 fontData.seek(tableOffset + 4);
803         metrics.ascender = fontData.readShort();
804         metrics.descender = fontData.readShort();
805         metrics.lineGap = fontData.readShort();
806         metrics.advanceWidthMax = fontData.readUnsignedShort();
807         metrics.minLeftSideBearing = fontData.readShort();
808         metrics.minRightSideBearing = fontData.readShort();
809         metrics.xMaxExtent = fontData.readShort();
810         metrics.caretSlopeRise = fontData.readShort();
811         metrics.caretSlopeRun = fontData.readShort();
812         // Go to the horizontal metrics count!
813 fontData.skip(12);
814         metrics.numberOfHMetrics = fontData.readUnsignedShort();
815       }
816       catch(Exception e)
817       {throw new RuntimeException (e);}
818
819       // PostScript ('post' table).
820 // Retrieve the location info!
821 tableOffset = tableOffsets.get("post");
822       if(tableOffset == 0)
823         throw new FontFileFormatException("'post' table does NOT exist.");
824
825       try
826       {
827         // Go to the italic angle!
828 fontData.seek(tableOffset + 4);
829         metrics.italicAngle =
830           fontData.readShort() // Fixed-point mantissa (16 bits).
831 + (float)fontData.readUnsignedShort() / 16384; // Fixed-point fraction (16 bits).
832 metrics.underlinePosition = fontData.readShort();
833         metrics.underlineThickness = fontData.readShort();
834         metrics.isFixedPitch = (fontData.readInt() != 0);
835       }
836       catch(Exception e)
837       {throw new RuntimeException (e);}
838     }
839
840     /**
841       Reads a string.
842     */
843     private String readString(
844       int length,
845       int platformID
846       )
847     {
848       // Which platform?
849 switch(platformID)
850       {
851         case 0: // Unicode.
852 case PlatformID_Microsoft:
853           return readString_unicode(length);
854         default:
855           return readString_ascii(length);
856       }
857     }
858
859     /**
860       Reads a string from the font file using the extended ASCII encoding.
861     */
862     private String readString_ascii(
863       int length
864       )
865     {
866       /*
867         NOTE: Extended ASCII (Latin1) is a single-byte encoding
868         (I know you already knew that!).
869       */
870       try
871       {
872         byte[] data = new byte[length];
873         fontData.read(data);
874
875         return new String (data,Encoding_Latin1);
876       }
877       catch(Exception e)
878       {throw new RuntimeException (e);}
879     }
880
881     /**
882       Reads a string from the font file using the Unicode encoding.
883     */
884     private String readString_unicode(
885       int length
886       )
887     {
888       /*
889         NOTE: Unicode is a double-byte encoding
890         (I know you already knew that!).
891       */
892       try
893       {
894         byte[] data = new byte[length];
895         fontData.read(data);
896
897         return new String (data,Encoding_Unicode);
898       }
899       catch(Exception e)
900       {throw new RuntimeException (e);}
901     }
902   }
903   // </classes>
904
905   // <dynamic>
906 // <fields>
907 private FontMetrics metrics;
908
909   private Hashtable <Integer ,Integer > glyphIndexes;
910   private Hashtable <Integer ,Integer > glyphKernings;
911   private int[] glyphWidths;
912   // </fields>
913
914   // <constructors>
915 public OpenTypeFont(
916     Document context,
917     IInputStream fontData
918     )
919   {
920     super(context);
921
922     load(fontData);
923   }
924
925   /**
926     <h3>Remarks</h3>
927     <p>For internal use only.</p>
928   */
929 //TODO:IMPL manage loading of already embedded font metrics to allow editing!!!
930 public OpenTypeFont(
931     PdfDirectObject baseObject
932     )
933   {super(baseObject);}
934   // </constructors>
935
936   // <interface>
937 // <public>
938 public Object clone(
939     Document context
940     )
941   {throw new NotImplementedException();}
942
943   @Override
944   public int getKerning(
945     char textChar1,
946     char textChar2
947     )
948   {
949     try
950     {
951       return glyphKernings.get(
952         glyphIndexes.get((int)textChar1) << 16 // Left-hand glyph index.
953 + glyphIndexes.get((int)textChar2) // Right-hand glyph index.
954 );
955     }
956     catch(Exception e)
957     {return 0;}
958   }
959
960   @Override
961   public int getKerning(
962     String text
963     )
964   {
965     int kerning = 0;
966     // Are kerning pairs available?
967 if(glyphKernings != null)
968     {
969       char textChars[] = text.toCharArray();
970       for(
971         int index = 0,
972           length = text.length() - 1;
973         index < length;
974         index++
975         )
976       {
977         kerning += getKerning(
978           textChars[index],
979           textChars[index + 1]
980           );
981       }
982     }
983
984     return kerning;
985   }
986
987   @Override
988   public int getWidth(
989     char textChar
990     )
991   {return glyphWidths[glyphIndexes.get((int)textChar)];}
992
993   @Override
994   public int getWidth(
995     String text
996     )
997   {
998     int width = 0;
999     char textChars[] = text.toCharArray();
1000    for(
1001      int index = 0,
1002        length = text.length();
1003      index < length;
1004      index++
1005      )
1006    {width += getWidth(textChars[index]);}
1007
1008    return width;
1009  }
1010  // </public>
1011
1012  /**
1013    Loads the font data.
1014  */
1015  private void load(
1016    IInputStream fontData
1017    )
1018  {
1019    try
1020    {
1021      Parser parser = new Parser(fontData);
1022
1023      // Subtype.
1024 getBaseDataObject().put(
1025        PdfName.Subtype,
1026        parser.subType
1027        );
1028      // BaseFont.
1029 getBaseDataObject().put(
1030        PdfName.BaseFont,
1031        new PdfName(parser.fontName)
1032        );
1033      // Encoding.
1034 /*
1035        NOTE: PDF font dictionary's Encoding entry is used in conjunction with a "cmap" to map
1036        from a character code in a string to a glyph description in an OpenType font program.
1037        * A nonsymbolic font SHOULD specify MacRomanEncoding or WinAnsiEncoding as the value of its
1038        Encoding entry, with no Differences array.
1039        * A symbolic font (used to display glyphs that do not use MacRomanEncoding or
1040        WinAnsiEncoding) SHOULD NOT specify an Encoding entry. The font descriptor's Symbolic flag
1041        should be set.
1042      */
1043      // Is it symbolic?
1044 if(metrics.isCustomEncoding) // Symbolic.
1045 {
1046        /*
1047          NOTE: Encoding entry MUST be null,
1048          whilst the font descriptor's Symbolic flag MUST be set.
1049        */
1050      }
1051      else // Nonsymbolic.
1052 {
1053        getBaseDataObject().put(PdfName.Encoding,PdfName.WinAnsiEncoding);
1054      }
1055      // TODO:IMPL subsetting to be managed!!!
1056 int firstChar = 0;
1057      int lastChar = 255;
1058      // FirstChar.
1059 getBaseDataObject().put(
1060        PdfName.FirstChar,
1061        new PdfInteger(firstChar)
1062        );
1063      // LastChar.
1064 getBaseDataObject().put(
1065        PdfName.LastChar,
1066        new PdfInteger(lastChar)
1067        );
1068      // Widths.
1069 PdfArray widthsObject = new PdfArray(lastChar - firstChar + 1);
1070      for(
1071        int code = firstChar;
1072        code <= lastChar;
1073        code++
1074        )
1075      {
1076        int width;
1077        try
1078        {width = glyphWidths[glyphIndexes.get(code)];}
1079        catch(Exception e)
1080        {width = 0;}
1081
1082        widthsObject.add(new PdfInteger(width));
1083      }
1084      getBaseDataObject().put(
1085        PdfName.Widths,
1086        widthsObject
1087        );
1088      // FontDescriptor.
1089 getBaseDataObject().put(
1090        PdfName.FontDescriptor,
1091        load_createFontDescriptor(fontData).getReference()
1092        );
1093    }
1094    catch(Exception e)
1095    {throw new RuntimeException (e);}
1096  }
1097
1098  /**
1099    Creates the font descriptor.
1100  */
1101  private PdfIndirectObject load_createFontDescriptor(
1102    IInputStream fontData
1103    )
1104  {
1105    PdfDictionary fontDescriptor = new PdfDictionary();
1106    // Type.
1107 fontDescriptor.put(
1108      PdfName.Type,
1109      PdfName.FontDescriptor
1110      );
1111    // FontName.
1112 fontDescriptor.put(
1113      PdfName.FontName,
1114      getBaseDataObject().get(PdfName.BaseFont)
1115      );
1116    // Flags [PDF:1.6:5.7.1].
1117 int flags = 0;
1118    if(metrics.isFixedPitch)
1119    {flags |= FlagsEnum.FixedPitch.getCode();}
1120    if(metrics.isCustomEncoding)
1121    {flags |= FlagsEnum.Symbolic.getCode();}
1122    else
1123    {flags |= FlagsEnum.Nonsymbolic.getCode();}
1124    fontDescriptor.put(
1125      PdfName.Flags,
1126      new PdfInteger(flags)
1127      );
1128    // FontBBox.
1129 fontDescriptor.put(
1130      PdfName.FontBBox,
1131      new PdfRectangle(
1132        metrics.xMin * metrics.unitNorm,
1133        metrics.yMin * metrics.unitNorm,
1134        metrics.xMax * metrics.unitNorm,
1135        metrics.yMax * metrics.unitNorm
1136        )
1137      );
1138    // ItalicAngle.
1139 fontDescriptor.put(
1140      PdfName.ItalicAngle,
1141      new PdfReal(metrics.italicAngle)
1142      );
1143    // Ascent.
1144 if(metrics.ascender == 0)
1145    {
1146        fontDescriptor.put(
1147          PdfName.Ascent,
1148          new PdfReal(metrics.sTypoAscender * metrics.unitNorm)
1149          );
1150    }
1151    else
1152    {
1153        fontDescriptor.put(
1154          PdfName.Ascent,
1155          new PdfReal(metrics.ascender * metrics.unitNorm)
1156          );
1157    }
1158    // Descent.
1159 if(metrics.descender == 0)
1160    {
1161        fontDescriptor.put(
1162          PdfName.Descent,
1163          new PdfReal(metrics.sTypoDescender * metrics.unitNorm)
1164          );
1165    }
1166    else
1167    {
1168        fontDescriptor.put(
1169          PdfName.Descent,
1170          new PdfReal(metrics.descender * metrics.unitNorm)
1171          );
1172    }
1173    // Leading.
1174 fontDescriptor.put(
1175      PdfName.Leading,
1176      new PdfReal(metrics.sTypoLineGap * metrics.unitNorm)
1177      );
1178    // CapHeight.
1179 fontDescriptor.put(
1180      PdfName.CapHeight,
1181      new PdfReal(metrics.sCapHeight * metrics.unitNorm)
1182      );
1183    // StemV.
1184 /*
1185      NOTE: '100' is just a rule-of-thumb value, 'cause I've still to solve the
1186      'cvt' table puzzle (such a harsh headache!) for TrueType fonts...
1187      TODO:IMPL TrueType and CFF stemv real value to extract!!!
1188    */
1189    fontDescriptor.put(
1190      PdfName.StemV,
1191      new PdfInteger(100)
1192      );
1193    // FontFile.
1194//TODO:IMPL distinguish between truetype (FontDescriptor.FontFile2) and opentype (FontDescriptor.FontFile3 and FontStream.subtype=OpenType)!!!
1195 PdfIndirectObject fontFile = getFile().getIndirectObjects().add(
1196      new PdfStream(
1197        new PdfDictionary(
1198          new PdfName[]{PdfName.Subtype},
1199          new PdfDirectObject[]{PdfName.OpenType}
1200          ),
1201        new Buffer(fontData.toByteArray())
1202        )
1203      );
1204    fontDescriptor.put(
1205      PdfName.FontFile3,
1206      fontFile.getReference()
1207      );
1208
1209    return getFile().getIndirectObjects().add(fontDescriptor);
1210  }
1211  // </interface>
1212 // </dynamic>
1213 // </class>
1214}

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Popular Tags