public virtual void WriteTextGlyphLineWithCustomEncodingTest()
{
FontEncoding fontEncoding = FontEncoding.CreateEmptyFontEncoding();
fontEncoding.AddSymbol(E_CUSTOM_CODE, E_CODE);
PdfSimpleFont <FontProgram> fontToTest = new PdfSimpleFontTest.TestSimpleFont(fontEncoding);
IList <Glyph> glyphs = new List <Glyph>();
glyphs.Add(E_GLYPH_FONT_SPECIFIC);
glyphs.Add(T_GLYPH_FONT_SPECIFIC);
GlyphLine glyphLine = new GlyphLine(glyphs, 0, 2);
MemoryStream bos = new MemoryStream();
using (PdfOutputStream pos = new PdfOutputStream(bos)) {
fontToTest.WriteText(glyphLine, 0, 1, pos);
}
NUnit.Framework.Assert.AreEqual(new byte[] { OPEN_BRACKET_CODE, E_CUSTOM_CODE, CLOSE_BRACKET_CODE }, bos.ToArray
());
}
internal PdfType1Font(Type1Font type1Font, String encoding, bool embedded)
: base()
{
SetFontProgram(type1Font);
this.embedded = embedded && !type1Font.IsBuiltInFont();
if ((encoding == null || encoding.Length == 0) && type1Font.IsFontSpecific())
{
encoding = FontEncoding.FONT_SPECIFIC;
}
if (encoding != null && FontEncoding.FONT_SPECIFIC.ToLower(System.Globalization.CultureInfo.InvariantCulture
).Equals(encoding.ToLower(System.Globalization.CultureInfo.InvariantCulture)))
{
fontEncoding = FontEncoding.CreateFontSpecificEncoding();
}
else
{
fontEncoding = FontEncoding.CreateFontEncoding(encoding);
}
}
internal static TrueTypeFont CreateFontProgram(PdfDictionary fontDictionary, FontEncoding fontEncoding, CMapToUnicode
toUnicode)
{
iText.Kernel.Font.DocTrueTypeFont fontProgram = new iText.Kernel.Font.DocTrueTypeFont(fontDictionary);
FillFontDescriptor(fontProgram, fontDictionary.GetAsDictionary(PdfName.FontDescriptor));
PdfNumber firstCharNumber = fontDictionary.GetAsNumber(PdfName.FirstChar);
int firstChar = firstCharNumber != null?Math.Max(firstCharNumber.IntValue(), 0) : 0;
int[] widths = FontUtil.ConvertSimpleWidthsArray(fontDictionary.GetAsArray(PdfName.Widths), firstChar, fontProgram
.GetMissingWidth());
fontProgram.avgWidth = 0;
int glyphsWithWidths = 0;
for (int i = 0; i < 256; i++)
{
Glyph glyph = new Glyph(i, widths[i], fontEncoding.GetUnicode(i));
fontProgram.codeToGlyph.Put(i, glyph);
//FontEncoding.codeToUnicode table has higher priority
if (glyph.HasValidUnicode() && fontEncoding.ConvertToByte(glyph.GetUnicode()) == i)
{
fontProgram.unicodeToGlyph.Put(glyph.GetUnicode(), glyph);
}
else
{
if (toUnicode != null)
{
glyph.SetChars(toUnicode.Lookup(i));
}
}
if (widths[i] > 0)
{
glyphsWithWidths++;
fontProgram.avgWidth += widths[i];
}
}
if (glyphsWithWidths != 0)
{
fontProgram.avgWidth /= glyphsWithWidths;
}
return(fontProgram);
}
public static FontEncoding CreateDocFontEncoding(PdfObject encoding, CMapToUnicode toUnicode, bool fillBaseEncoding
)
{
if (encoding != null)
{
if (encoding.IsName())
{
return(FontEncoding.CreateFontEncoding(((PdfName)encoding).GetValue()));
}
else
{
if (encoding.IsDictionary())
{
iText.Kernel.Font.DocFontEncoding fontEncoding = new iText.Kernel.Font.DocFontEncoding();
fontEncoding.differences = new String[256];
if (fillBaseEncoding)
{
FillBaseEncoding(fontEncoding, ((PdfDictionary)encoding).GetAsName(PdfName.BaseEncoding));
}
FillDifferences(fontEncoding, ((PdfDictionary)encoding).GetAsArray(PdfName.Differences), toUnicode);
return(fontEncoding);
}
}
}
if (toUnicode != null)
{
iText.Kernel.Font.DocFontEncoding fontEncoding = new iText.Kernel.Font.DocFontEncoding();
fontEncoding.differences = new String[256];
FillDifferences(fontEncoding, toUnicode);
return(fontEncoding);
}
else
{
return(FontEncoding.CreateFontSpecificEncoding());
}
}
//---------------------------------------------------------------------
public static string GetEncodingDescription(FontEncoding encoding)
{
return(new wxString(wxFontMapper_GetEncodingDescription((int)encoding), true));
}
//---------------------------------------------------------------------
public bool GetAltForEncoding(FontEncoding encoding, out FontEncoding alt_encoding)
{
return(GetAltForEncoding(encoding, out alt_encoding, "", true));
}
public bool GetAltForEncoding(FontEncoding encoding, out FontEncoding alt_encoding, string facename)
{
return(GetAltForEncoding(encoding, out alt_encoding, facename, true));
}
public virtual void ConvertGlyphLineToBytesWithEmptyEncodingTest()
{
PdfSimpleFont <FontProgram> fontToTest = new PdfSimpleFontTest.TestSimpleFont(FontEncoding.CreateEmptyFontEncoding
());
IList <Glyph> glyphs = new List <Glyph>();
glyphs.Add(T_GLYPH_FONT_SPECIFIC);
glyphs.Add(E_GLYPH_FONT_SPECIFIC);
GlyphLine glyphLine = new GlyphLine(glyphs, 0, 2);
byte[] bytes = fontToTest.ConvertToBytes(glyphLine);
NUnit.Framework.Assert.AreEqual(new byte[0], bytes);
}
public bool IsEncodingAvailable(FontEncoding encoding, string facename)
{
return(wxFontMapper_IsEncodingAvailable(wxObject, (int)encoding, facename));
}
//---------------------------------------------------------------------
/*public virtual bool EnumerateFacenames()
* {
* return EnumerateFacenames((int)FontEncoding.wxFONTENCODING_SYSTEM, false);
* }
*
* public virtual bool EnumerateFacenames(FontEncoding encoding)
* {
* return EnumerateFacenames((int)encoding, false);
* }*/
public virtual bool EnumerateFacenames(FontEncoding encoding, bool fixedWidthOnly)
{
return(wxFontEnumerator_EnumerateFacenames(wxObject, (int)encoding, fixedWidthOnly));
}
/// <summary>Returns the Font.</summary>
/// <returns>the font</returns>
/// <exception cref="System.IO.IOException"/>
public virtual FontProgram GetFont()
{
if (font != null)
{
return(font);
}
FontProgram ff2 = FontProgramFactory.CreateRegisteredFont(faceName, ((italic != 0) ? FontConstants.ITALIC :
0) | ((bold != 0) ? FontConstants.BOLD : 0));
encoding = FontEncoding.CreateFontEncoding(PdfEncodings.WINANSI);
font = ff2;
if (font != null)
{
return(font);
}
String fontName;
if (faceName.Contains("courier") || faceName.Contains("terminal") || faceName.Contains("fixedsys"))
{
fontName = fontNames[MARKER_COURIER + italic + bold];
}
else
{
if (faceName.Contains("ms sans serif") || faceName.Contains("arial") || faceName.Contains("system"))
{
fontName = fontNames[MARKER_HELVETICA + italic + bold];
}
else
{
if (faceName.Contains("arial black"))
{
fontName = fontNames[MARKER_HELVETICA + italic + MARKER_BOLD];
}
else
{
if (faceName.Contains("times") || faceName.Contains("ms serif") || faceName.Contains("roman"))
{
fontName = fontNames[MARKER_TIMES + italic + bold];
}
else
{
if (faceName.Contains("symbol"))
{
fontName = fontNames[MARKER_SYMBOL];
}
else
{
int pitch = pitchAndFamily & 3;
int family = (pitchAndFamily >> 4) & 7;
switch (family)
{
case FF_MODERN: {
fontName = fontNames[MARKER_COURIER + italic + bold];
break;
}
case FF_ROMAN: {
fontName = fontNames[MARKER_TIMES + italic + bold];
break;
}
case FF_SWISS:
case FF_SCRIPT:
case FF_DECORATIVE: {
fontName = fontNames[MARKER_HELVETICA + italic + bold];
break;
}
default: {
switch (pitch)
{
case FIXED_PITCH: {
fontName = fontNames[MARKER_COURIER + italic + bold];
break;
}
default: {
fontName = fontNames[MARKER_HELVETICA + italic + bold];
break;
}
}
break;
}
}
}
}
}
}
}
try {
font = FontProgramFactory.CreateFont(fontName);
encoding = FontEncoding.CreateFontEncoding(PdfEncodings.WINANSI);
}
catch (System.IO.IOException e) {
throw new Exception(e.Message, e);
}
return(font);
}
public virtual void CreateGlyphLineWithEmptyEncodingTest()
{
PdfSimpleFont <FontProgram> fontToTest = new PdfSimpleFontTest.TestSimpleFont(FontEncoding.CreateEmptyFontEncoding
());
GlyphLine glyphLine = fontToTest.CreateGlyphLine("te");
IList <Glyph> glyphs = new List <Glyph>();
glyphs.Add(E_GLYPH_CUSTOM_MAPPED);
GlyphLine expected = new GlyphLine(glyphs, 0, 1);
NUnit.Framework.Assert.AreEqual(expected, glyphLine);
}
public virtual void AppendGlyphsWithSpecificEncodingTest()
{
PdfSimpleFont <FontProgram> fontToTest = new PdfSimpleFontTest.TestSimpleFont(FontEncoding.CreateFontSpecificEncoding
());
IList <Glyph> toAppend = new List <Glyph>();
int processed = fontToTest.AppendGlyphs("te", 0, 1, toAppend);
NUnit.Framework.Assert.AreEqual(2, processed);
IList <Glyph> glyphs = new List <Glyph>();
glyphs.Add(T_GLYPH_FONT_SPECIFIC);
glyphs.Add(E_GLYPH_FONT_SPECIFIC);
NUnit.Framework.Assert.AreEqual(glyphs, toAppend);
}
public TestSimpleFont(FontEncoding fontEncoding)
{
this.fontEncoding = fontEncoding;
SetFontProgram(FontProgramFactory.CreateFont(StandardFonts.HELVETICA));
}
public virtual void CreateGlyphLineWithSpecificEncodingTest()
{
PdfSimpleFont <FontProgram> fontToTest = new PdfSimpleFontTest.TestSimpleFont(FontEncoding.CreateFontSpecificEncoding
());
GlyphLine glyphLine = fontToTest.CreateGlyphLine("te");
IList <Glyph> glyphs = new List <Glyph>();
glyphs.Add(T_GLYPH_FONT_SPECIFIC);
glyphs.Add(E_GLYPH_FONT_SPECIFIC);
GlyphLine expected = new GlyphLine(glyphs, 0, 2);
NUnit.Framework.Assert.AreEqual(expected, glyphLine);
}
/// <summary>
/// Converts a string with the specified font encoding to a byte[]
/// and then returns the Hexadecimal string of that byte array
/// </summary>
/// <param name="value">The value to be converted</param>
/// <param name="encoding">The encoding of the value</param>
/// <returns>A hexadecimal string representation</returns>
private string ToHex(string value, FontEncoding encoding)
{
Scryber.Text.PDFEncoding enc = Scryber.Text.PDFEncoding.GetEncoding(encoding);
byte[] all = enc.GetBytes(value);
return(ToHex(all));
}
public virtual void ConvertGlyphToBytesWithEmptyEncodingTest()
{
PdfSimpleFont <FontProgram> fontToTest = new PdfSimpleFontTest.TestSimpleFont(FontEncoding.CreateEmptyFontEncoding
());
byte[] bytes = fontToTest.ConvertToBytes(E_GLYPH_FONT_SPECIFIC);
NUnit.Framework.Assert.AreEqual(new byte[0], bytes);
}
public virtual void ConvertToBytesWithNullEntry()
{
PdfSimpleFont <FontProgram> fontToTest = new PdfSimpleFontTest.TestSimpleFont(FontEncoding.CreateEmptyFontEncoding
());
byte[] bytes = fontToTest.ConvertToBytes((GlyphLine)null);
NUnit.Framework.Assert.AreEqual(new byte[0], bytes);
}
//---------------------------------------------------------------------
public bool Init(FontEncoding input_enc, FontEncoding output_enc)
{
return(Init(input_enc, output_enc, (int)CONVERT.wxCONVERT_STRICT));
}
public Font FindOrCreateFont(int pointSize, int family, int style, int weight, bool underline, string face, FontEncoding encoding)
{
return(new Font(wxFontList_FindOrCreateFont(wxObject, pointSize, family, style, weight, underline, face, encoding)));
}
public bool Init(FontEncoding input_enc, FontEncoding output_enc, int method)
{
return(wxEncodingConverter_Init(wxObject, (int)input_enc, (int)output_enc, method));
}
[DllImport("wx-c"), System.Security.SuppressUnmanagedCodeSecurity] static extern IntPtr wxFont_ctor(int pointSize, int family, int style, int weight, bool underline, string faceName, FontEncoding encoding);
public static extern FreeTypeError FT_Select_Charmap(IntPtr face, FontEncoding fontEncoding);
[DllImport("wx-c"), System.Security.SuppressUnmanagedCodeSecurity] static extern IntPtr wxFontList_FindOrCreateFont(IntPtr self,
int pointSize,
int family,
int style,
int weight,
bool underline,
string face,
FontEncoding encoding);
internal static Type1Font CreateFontProgram(PdfDictionary fontDictionary, FontEncoding fontEncoding, CMapToUnicode
toUnicode)
{
PdfName baseFontName = fontDictionary.GetAsName(PdfName.BaseFont);
String baseFont;
if (baseFontName != null)
{
baseFont = baseFontName.GetValue();
}
else
{
baseFont = FontUtil.CreateRandomFontName();
}
if (!fontDictionary.ContainsKey(PdfName.FontDescriptor))
{
Type1Font type1StdFont;
try {
//if there are no font modifiers, cached font could be used,
//otherwise a new instance should be created.
type1StdFont = (Type1Font)FontProgramFactory.CreateFont(baseFont, true);
}
catch (Exception) {
type1StdFont = null;
}
if (type1StdFont != null)
{
return(type1StdFont);
}
}
iText.Kernel.Font.DocType1Font fontProgram = new iText.Kernel.Font.DocType1Font(baseFont);
PdfDictionary fontDesc = fontDictionary.GetAsDictionary(PdfName.FontDescriptor);
fontProgram.subtype = fontDesc.GetAsName(PdfName.Subtype);
FillFontDescriptor(fontProgram, fontDesc);
PdfNumber firstCharNumber = fontDictionary.GetAsNumber(PdfName.FirstChar);
int firstChar = firstCharNumber != null?Math.Max(firstCharNumber.IntValue(), 0) : 0;
int[] widths = FontUtil.ConvertSimpleWidthsArray(fontDictionary.GetAsArray(PdfName.Widths), firstChar, fontProgram
.GetMissingWidth());
fontProgram.avgWidth = 0;
int glyphsWithWidths = 0;
for (int i = 0; i < 256; i++)
{
Glyph glyph = new Glyph(i, widths[i], fontEncoding.GetUnicode(i));
fontProgram.codeToGlyph[i] = glyph;
if (glyph.HasValidUnicode())
{
//FontEncoding.codeToUnicode table has higher priority
if (fontEncoding.ConvertToByte(glyph.GetUnicode()) == i)
{
fontProgram.unicodeToGlyph[glyph.GetUnicode()] = glyph;
}
}
else
{
if (toUnicode != null)
{
glyph.SetChars(toUnicode.Lookup(i));
}
}
if (widths[i] > 0)
{
glyphsWithWidths++;
fontProgram.avgWidth += widths[i];
}
}
if (glyphsWithWidths != 0)
{
fontProgram.avgWidth /= glyphsWithWidths;
}
return(fontProgram);
}
public virtual void AppendAnyGlyphWithEmptyEncodingTest()
{
PdfSimpleFont <FontProgram> fontToTest = new PdfSimpleFontTest.TestSimpleFont(FontEncoding.CreateEmptyFontEncoding
());
IList <Glyph> toAppend = new List <Glyph>();
int processed = fontToTest.AppendAnyGlyph("e ete", 0, toAppend);
NUnit.Framework.Assert.AreEqual(1, processed);
IList <Glyph> glyphs = new List <Glyph>();
glyphs.Add(E_GLYPH_CUSTOM_MAPPED);
NUnit.Framework.Assert.AreEqual(glyphs, toAppend);
}
/// <summary>
/// Encodes the specified string.
/// </summary>
/// <param name="text">The text to encode.</param>
/// <param name="encoding">The target encoding.</param>
/// <returns>The encoded text</returns>
private static string EncodeString(string text, FontEncoding encoding)
{
// TODO
return(text);
}
//---------------------------------------------------------------------
public static string GetEncodingName(FontEncoding encoding)
{
return(new wxString(wxFontMapper_GetEncodingName((int)encoding), true));
}
public Font(int pointSize, FontFamily family, FontStyle style, FontWeight weight, bool underline, string faceName, FontEncoding encoding)
: this(wxFont_ctor(pointSize, (int)family, (int)style, (int)weight, underline, faceName, encoding), true)
{
}
//---------------------------------------------------------------------
public bool IsEncodingAvailable(FontEncoding encoding)
{
return(IsEncodingAvailable(encoding, ""));
}
