/// <exception cref="System.IO.IOException"/> public OpenTypeParser(String name) { String nameBase = FontProgram.GetBaseName(name); String ttcName = GetTTCName(nameBase); this.fileName = ttcName; if (ttcName.Length < nameBase.Length) { ttcIndex = System.Convert.ToInt32(nameBase.Substring(ttcName.Length + 1)); } raf = new RandomAccessFileOrArray(new RandomAccessSourceFactory().CreateBestSource(fileName)); Process(); }
/// <summary>Creates a new font.</summary> /// <remarks> /// Creates a new font. This font can be one of the 14 built in types, /// a Type1 font referred to by an AFM or PFM file, a TrueType font (simple or collection) or a CJK font from the /// Adobe Asian Font Pack. TrueType fonts and CJK fonts can have an optional style modifier /// appended to the name. These modifiers are: Bold, Italic and BoldItalic. An /// example would be "STSong-Light,Bold". Note that this modifiers do not work if /// the font is embedded. Fonts in TrueType collections are addressed by index such as "msgothic.ttc,1". /// This would get the second font (indexes start at 0), in this case "MS PGothic". /// <p/> /// The fonts may or may not be cached depending on the flag <CODE>cached</CODE>. /// If the <CODE>byte</CODE> arrays are present the font will be /// read from them instead of the name. A name is still required to identify /// the font type. /// <p/> /// Besides the common encodings described by name, custom encodings /// can also be made. These encodings will only work for the single byte fonts /// Type1 and TrueType. The encoding string starts with a '#' /// followed by "simple" or "full". If "simple" there is a decimal for the first character position and then a list /// of hex values representing the Unicode codes that compose that encoding.<br /> /// The "simple" encoding is recommended for TrueType fonts /// as the "full" encoding risks not matching the character with the right glyph /// if not done with care.<br /> /// The "full" encoding is specially aimed at Type1 fonts where the glyphs have to be /// described by non standard names like the Tex math fonts. Each group of three elements /// compose a code position: the one byte code order in decimal or as 'x' (x cannot be the space), the name and the Unicode character /// used to access the glyph. The space must be assigned to character position 32 otherwise /// text justification will not work. /// <p/> /// Example for a "simple" encoding that includes the Unicode /// character space, A, B and ecyrillic: /// <PRE> /// "# simple 32 0020 0041 0042 0454" /// </PRE> /// <p/> /// Example for a "full" encoding for a Type1 Tex font: /// <PRE> /// "# full 'A' nottriangeqlleft 0041 'B' dividemultiply 0042 32 space 0020" /// </PRE> /// </remarks> /// <param name="name">the name of the font or its location on file</param> /// <param name="font">the true type font or the afm in a byte array</param> /// <param name="cached"> /// true if the font comes from the cache or is added to /// the cache if new, false if the font is always created new /// </param> /// <returns> /// returns a new font. This font may come from the cache but only if cached /// is true, otherwise it will always be created new /// </returns> /// <exception cref="System.IO.IOException"/> public static FontProgram CreateFont(String name, byte[] font, bool cached) { String baseName = FontProgram.GetBaseName(name); //yes, we trying to find built-in standard font with original name, not baseName. bool isBuiltinFonts14 = FontConstants.BUILTIN_FONTS_14.Contains(name); bool isCidFont = !isBuiltinFonts14 && FontCache.IsPredefinedCidFont(baseName); FontProgram fontFound; if (cached && name != null) { fontFound = FontCache.GetFont(name); if (fontFound != null) { return(fontFound); } } if (name == null) { if (font != null) { try { return(new TrueTypeFont(font)); } catch (Exception) { } try { return(new Type1Font(null, null, font, null)); } catch (Exception) { } } throw new iText.IO.IOException(iText.IO.IOException.FontIsNotRecognized); } FontProgram fontBuilt; if (isBuiltinFonts14 || name.ToLower(System.Globalization.CultureInfo.InvariantCulture).EndsWith(".afm") || name.ToLower(System.Globalization.CultureInfo.InvariantCulture).EndsWith(".pfm")) { fontBuilt = new Type1Font(name, null, font, null); } else { if (baseName.ToLower(System.Globalization.CultureInfo.InvariantCulture).EndsWith(".ttf") || baseName.ToLower (System.Globalization.CultureInfo.InvariantCulture).EndsWith(".otf") || baseName.ToLower(System.Globalization.CultureInfo.InvariantCulture ).IndexOf(".ttc,") > 0) { if (font != null) { fontBuilt = new TrueTypeFont(font); } else { fontBuilt = new TrueTypeFont(name); } } else { if (isCidFont) { fontBuilt = new CidFont(name, FontCache.GetCompatibleCmaps(baseName)); } else { throw new iText.IO.IOException(iText.IO.IOException.Font1IsNotRecognized).SetMessageParams(name); } } } return(cached ? FontCache.SaveFont(fontBuilt, name) : fontBuilt); }