public static int[] GetWidthArray(StandardFonts font)
{
switch (font)
{
case StandardFonts.Courier:
case StandardFonts.CourierOblique:
case StandardFonts.CourierBold:
case StandardFonts.CourierBoldOblique:
return(Courier);
case StandardFonts.Helvetica:
case StandardFonts.HelveticaOblique:
return(Helvetica);
case StandardFonts.HelveticaBold:
case StandardFonts.HelveticaBoldOblique:
return(HelveticaBold);
case StandardFonts.Symbol:
return(Symbol);
case StandardFonts.Times:
return(Times);
case StandardFonts.TimesBold:
return(TimesBold);
case StandardFonts.TimesBoldItalic:
return(TimesBoldItalic);
case StandardFonts.TimesItalic:
return(TimesItalic);
case StandardFonts.ZapfDingbats:
return(ZapfDingbats);
}
return(null);
}
public static FontProgramDescriptor FetchDescriptor(String fontName)
{
if (fontName == null || fontName.Length == 0)
{
return(null);
}
String baseName = FontProgram.TrimFontStyle(fontName);
//yes, we trying to find built-in standard font with original name, not baseName.
bool isBuiltinFonts14 = StandardFonts.IsStandardFont(fontName);
bool isCidFont = !isBuiltinFonts14 && FontCache.IsPredefinedCidFont(baseName);
FontProgramDescriptor fontDescriptor = null;
if (FETCH_CACHED_FIRST)
{
fontDescriptor = FetchCachedDescriptor(fontName, null);
if (fontDescriptor != null)
{
return(fontDescriptor);
}
}
try {
String fontNameLowerCase = baseName.ToLowerInvariant();
if (isBuiltinFonts14 || fontNameLowerCase.EndsWith(".afm") || fontNameLowerCase.EndsWith(".pfm"))
{
fontDescriptor = FetchType1FontDescriptor(fontName, null);
}
else
{
if (isCidFont)
{
fontDescriptor = FetchCidFontDescriptor(fontName);
}
else
{
if (fontNameLowerCase.EndsWith(".ttf") || fontNameLowerCase.EndsWith(".otf"))
{
fontDescriptor = FetchTrueTypeFontDescriptor(fontName);
}
else
{
if (fontNameLowerCase.EndsWith(".woff") || fontNameLowerCase.EndsWith(".woff2"))
{
byte[] fontProgram;
if (fontNameLowerCase.EndsWith(".woff"))
{
fontProgram = WoffConverter.Convert(FontProgramFactory.ReadFontBytesFromPath(baseName));
}
else
{
fontProgram = Woff2Converter.Convert(FontProgramFactory.ReadFontBytesFromPath(baseName));
}
fontDescriptor = FetchTrueTypeFontDescriptor(fontProgram);
}
else
{
fontDescriptor = FetchTTCDescriptor(baseName);
}
}
}
}
}
catch (Exception) {
fontDescriptor = null;
}
return(fontDescriptor);
}
/// <exception cref="System.IO.IOException"/>
public virtual RandomAccessFileOrArray GetMetricsFile()
{
isBuiltInFont = false;
if (StandardFonts.IsStandardFont(afmPath))
{
isBuiltInFont = true;
byte[] buf = new byte[1024];
Stream resource = null;
try {
String resourcePath = FontResources.AFMS + afmPath + ".afm";
resource = ResourceUtil.GetResourceStream(resourcePath);
if (resource == null)
{
throw new iText.IO.IOException("{0} was not found as resource.").SetMessageParams(resourcePath);
}
MemoryStream stream = new MemoryStream();
int read;
while ((read = resource.Read(buf)) >= 0)
{
stream.Write(buf, 0, read);
}
buf = stream.ToArray();
}
finally {
if (resource != null)
{
try {
resource.Dispose();
}
catch (Exception) {
}
}
}
return(new RandomAccessFileOrArray(sourceFactory.CreateSource(buf)));
}
else
{
if (afmPath != null)
{
if (afmPath.ToLowerInvariant().EndsWith(".afm"))
{
return(new RandomAccessFileOrArray(sourceFactory.CreateBestSource(afmPath)));
}
else
{
if (afmPath.ToLowerInvariant().EndsWith(".pfm"))
{
MemoryStream ba = new MemoryStream();
RandomAccessFileOrArray rf = new RandomAccessFileOrArray(sourceFactory.CreateBestSource(afmPath));
Pfm2afm.Convert(rf, ba);
rf.Close();
return(new RandomAccessFileOrArray(sourceFactory.CreateSource(ba.ToArray())));
}
else
{
throw new iText.IO.IOException(iText.IO.IOException._1IsNotAnAfmOrPfmFontFile).SetMessageParams(afmPath);
}
}
}
else
{
if (afmData != null)
{
RandomAccessFileOrArray rf = new RandomAccessFileOrArray(sourceFactory.CreateSource(afmData));
if (IsAfmFile(rf))
{
return(rf);
}
else
{
MemoryStream ba = new MemoryStream();
try {
Pfm2afm.Convert(rf, ba);
}
catch (Exception) {
throw new iText.IO.IOException("Invalid afm or pfm font file.");
}
finally {
rf.Close();
}
return(new RandomAccessFileOrArray(sourceFactory.CreateSource(ba.ToArray())));
}
}
else
{
throw new iText.IO.IOException("Invalid afm or pfm font file.");
}
}
}
}
private static FontProgram CreateFont(String name, byte[] fontProgram, bool cached)
{
String baseName = FontProgram.TrimFontStyle(name);
//yes, we trying to find built-in standard font with original name, not baseName.
bool isBuiltinFonts14 = StandardFonts.IsStandardFont(name);
bool isCidFont = !isBuiltinFonts14 && FontCache.IsPredefinedCidFont(baseName);
FontProgram fontFound;
FontCacheKey fontKey = null;
if (cached)
{
fontKey = CreateFontCacheKey(name, fontProgram);
fontFound = FontCache.GetFont(fontKey);
if (fontFound != null)
{
return(fontFound);
}
}
FontProgram fontBuilt = null;
if (name == null)
{
if (fontProgram != null)
{
try {
if (WoffConverter.IsWoffFont(fontProgram))
{
fontProgram = WoffConverter.Convert(fontProgram);
}
else
{
if (Woff2Converter.IsWoff2Font(fontProgram))
{
fontProgram = Woff2Converter.Convert(fontProgram);
}
}
fontBuilt = new TrueTypeFont(fontProgram);
}
catch (Exception) {
}
if (fontBuilt == null)
{
try {
fontBuilt = new Type1Font(null, null, fontProgram, null);
}
catch (Exception) {
}
}
}
}
else
{
String fontFileExtension = null;
int extensionBeginIndex = baseName.LastIndexOf('.');
if (extensionBeginIndex > 0)
{
fontFileExtension = baseName.Substring(extensionBeginIndex).ToLowerInvariant();
}
if (isBuiltinFonts14 || ".afm".Equals(fontFileExtension) || ".pfm".Equals(fontFileExtension))
{
fontBuilt = new Type1Font(name, null, null, null);
}
else
{
if (isCidFont)
{
fontBuilt = new CidFont(name, FontCache.GetCompatibleCmaps(baseName));
}
else
{
if (".ttf".Equals(fontFileExtension) || ".otf".Equals(fontFileExtension))
{
if (fontProgram != null)
{
fontBuilt = new TrueTypeFont(fontProgram);
}
else
{
fontBuilt = new TrueTypeFont(name);
}
}
else
{
if (".woff".Equals(fontFileExtension) || ".woff2".Equals(fontFileExtension))
{
if (fontProgram == null)
{
fontProgram = ReadFontBytesFromPath(baseName);
}
if (".woff".Equals(fontFileExtension))
{
try {
fontProgram = WoffConverter.Convert(fontProgram);
}
catch (ArgumentException woffException) {
throw new iText.IO.IOException(iText.IO.IOException.InvalidWoffFile, woffException);
}
}
else
{
// ".woff2".equals(fontFileExtension)
try {
fontProgram = Woff2Converter.Convert(fontProgram);
}
catch (FontCompressionException woff2Exception) {
throw new iText.IO.IOException(iText.IO.IOException.InvalidWoff2File, woff2Exception);
}
}
fontBuilt = new TrueTypeFont(fontProgram);
}
else
{
int ttcSplit = baseName.ToLowerInvariant().IndexOf(".ttc,", StringComparison.Ordinal);
if (ttcSplit > 0)
{
try {
// count(.ttc) = 4
String ttcName = baseName.JSubstring(0, ttcSplit + 4);
// count(.ttc,) = 5)
int ttcIndex = Convert.ToInt32(baseName.Substring(ttcSplit + 5));
fontBuilt = new TrueTypeFont(ttcName, ttcIndex);
}
catch (FormatException nfe) {
throw new iText.IO.IOException(nfe.Message, nfe);
}
}
}
}
}
}
}
if (fontBuilt == null)
{
if (name != null)
{
throw new iText.IO.IOException(iText.IO.IOException.TypeOfFont1IsNotRecognized).SetMessageParams(name);
}
else
{
throw new iText.IO.IOException(iText.IO.IOException.TypeOfFontIsNotRecognized);
}
}
return(cached ? FontCache.SaveFont(fontBuilt, fontKey) : fontBuilt);
}
private bool isStandardFont(out StandardFonts fontType)
{
string name = Name.ToLower();
if (name.Contains("symbol"))
{
fontType = StandardFonts.Symbol;
return(true);
}
else if (name.Contains("zapfdingbats"))
{
fontType = StandardFonts.ZapfDingbats;
return(true);
}
bool bold = name.Contains("bold");
bool italic = false;
if (name.Contains("oblique") || name.Contains("italic"))
{
italic = true;
}
if (name.Contains("courier"))
{
if (bold && italic)
{
fontType = StandardFonts.CourierBoldOblique;
return(true);
}
if (bold)
{
fontType = StandardFonts.CourierBold;
return(true);
}
if (italic)
{
fontType = StandardFonts.CourierOblique;
return(true);
}
fontType = StandardFonts.Courier;
return(true);
}
else if (name.Contains("helvetica"))
{
if (bold && italic)
{
fontType = StandardFonts.HelveticaBoldOblique;
return(true);
}
if (bold)
{
fontType = StandardFonts.HelveticaBold;
return(true);
}
if (italic)
{
fontType = StandardFonts.HelveticaOblique;
return(true);
}
fontType = StandardFonts.Helvetica;
return(true);
}
else if (name.Contains("times"))
{
if (bold && italic)
{
fontType = StandardFonts.TimesBoldItalic;
return(true);
}
if (bold)
{
fontType = StandardFonts.TimesBold;
return(true);
}
if (italic)
{
fontType = StandardFonts.TimesItalic;
return(true);
}
fontType = StandardFonts.Times;
return(true);
}
fontType = StandardFonts.Helvetica;
return(false);
}
/// <summary>
/// Initializes a new instance of the standard font with specified properties.
/// </summary>
/// <param name="standardFont">The Bytescout.PDF.StandardFonts value that specifies the standard font.</param>
/// <param name="emSize" href="http://msdn.microsoft.com/en-us/library/system.single.aspx">The em-size, in points, of the font.</param>
public Font(StandardFonts standardFont, float emSize)
: this(standardFont, emSize, false, false)
{
}
public static int GetWidth(byte ch, StandardFonts font)
{
int[] widths = GetWidthArray(font);
return(widths[ch - 32]);
}
