private WW.Pdf.Font.Font method_1()
{
switch (this.fontType_0)
{
case FontType.Embed:
this.font_0 = (WW.Pdf.Font.Font) new Class31(this.fontProperties_0);
break;
case FontType.Subset:
this.font_0 = (WW.Pdf.Font.Font) new Class32(this.fontProperties_0);
break;
}
bool flag = false;
IFontDescriptor descriptor = this.font_0.Descriptor;
if (!descriptor.IsEmbeddable)
{
flag = true;
}
if (this.font_0 is Class32 && !descriptor.IsSubsettable)
{
flag = true;
}
if (flag)
{
this.font_0 = !this.fontProperties_0.IsBoldItalic ? (!this.fontProperties_0.IsBold ? (!this.fontProperties_0.IsItalic ? Class14.font_4 : Class14.font_6) : Class14.font_5) : Class14.font_7;
}
return(this.font_0);
}
private Font LoadCIDFont()
{
switch (fontType)
{
case FontType.Embed:
realFont = new Type2CIDFont(properties);
break;
case FontType.Subset:
realFont = new Type2CIDSubsetFont(properties);
break;
}
// Flag that indicates whether the CID font should be replaced by a
// base 14 font due to a license violation
bool replaceFont = false;
IFontDescriptor descriptor = realFont.Descriptor;
if (!descriptor.IsEmbeddable)
{
PdfCreatorBridge.Warning(
String.Format("Unable to embed font '{0}' because the license states embedding is not allowed. Will default to Helvetica.",
realFont.FontName));
replaceFont = true;
}
// TODO: Do not permit subsetting if license does not allow it
if (realFont is Type2CIDSubsetFont && !descriptor.IsSubsettable)
{
PdfCreatorBridge.Warning(
String.Format("Unable to subset font '{0}' because the license states subsetting is not allowed.. Will default to Helvetica.",
realFont.FontName));
replaceFont = true;
}
if (replaceFont)
{
if (properties.IsBoldItalic)
{
realFont = Base14Font.HelveticaBoldItalic;
}
else if (properties.IsBold)
{
realFont = Base14Font.HelveticaBold;
}
else if (properties.IsItalic)
{
realFont = Base14Font.HelveticaItalic;
}
else
{
realFont = Base14Font.Helvetica;
}
}
return(realFont);
}
/// <summary>
/// Draw a string with the given font at the given location.
/// </summary>
/// <param name="text">The string to write.</param>
/// <param name="font">The font to use to draw. This must be a <see cref="FontDescriptor"/> object.</param>
/// <param name="x">X coordinate of the top-left corner of the drawn string.</param>
/// <param name="y">Y coordinate of the top-left corner of the drawn string.</param>
/// <exception cref="ArgumentException" />Thrown if the <see cref="IFontDescriptor" /> parameter is not a <see cref="FontDescriptor" /> object.
public void DrawString(string text, IFontDescriptor font, double x, double y)
{
if (!(font is FontDescriptor ourFont))
{
throw new ArgumentException(Resources.Error_FontDescriptorOfWrongSpecificType, nameof(font));
}
_core.DrawString(text, ourFont.Font, XBrushes.Black, x, y);
}
public void WordClass_MakeWordsMethod_ThrowsArgumentNullException_IfFirstParameterIsNotNullAndSecondParameterIsNull()
{
string testParam0 = _rnd.NextString(_rnd.Next(300));
IFontDescriptor testParam1 = null;
IGraphicsContext testParam2 = new Mock <IGraphicsContext>().Object;
_ = Word.MakeWords(testParam0, testParam1, testParam2).ToArray();
Assert.Fail();
}
/// <summary>
/// Measures the dimensions of a string drawn using this graphics context in a given font.
/// </summary>
/// <param name="text">The text to measure.</param>
/// <param name="font">The font to use to render the string. Must be a <see cref="FontDescriptor"/> object.</param>
/// <returns>The dimensions of the string when rendered.</returns>
/// <exception cref="ArgumentException" />Thrown if the <see cref="IFontDescriptor" /> paramter is not a <see cref="FontDescriptor" /> instance.
public UniSize MeasureString(string text, IFontDescriptor font)
{
if (!(font is FontDescriptor ourFont))
{
throw new ArgumentException(Resources.Error_FontDescriptorOfWrongSpecificType, nameof(font));
}
var size = _core.MeasureString(text, ourFont.Font);
return(new UniSize(size.Width, size.Height));
}
/// <summary>
/// Creates a character indexed font from <i>cidFont</i>
/// </summary>
/// <remarks>
/// The <i>font</i> and <i>cidFont</i> will be different object
/// references since the <i>font</i> parameter will most likely
/// be a <see cref="ProxyFont"/>.
/// </remarks>
/// <param name="pdfFontID">The Pdf font identifier, e.g. F15</param>
/// <param name="font">Required to access the font descriptor.</param>
/// <param name="cidFont">The underlying CID font.</param>
/// <returns></returns>
private PdfFont CreateCIDFont(
string pdfFontID, Font font, CIDFont cidFont)
{
// The font descriptor is required to access licensing details are
// obtain the font program itself as a byte array
IFontDescriptor descriptor = font.Descriptor;
// A compressed stream that stores the font program
PdfFontFile fontFile = new PdfFontFile(
NextObjectId(), descriptor.FontData);
// Add indirect reference to FontFile object to descriptor
PdfFontDescriptor pdfDescriptor = MakeFontDescriptor(pdfFontID, cidFont);
pdfDescriptor.FontFile2 = fontFile;
PdfCIDSystemInfo pdfCidSystemInfo = new PdfCIDSystemInfo(
cidFont.Registry, cidFont.Ordering, cidFont.Supplement);
PdfCIDFont pdfCidFont = new PdfCIDFont(
NextObjectId(), PdfFontSubTypeEnum.CIDFontType2, font.FontName);
pdfCidFont.SystemInfo = pdfCidSystemInfo;
pdfCidFont.Descriptor = pdfDescriptor;
pdfCidFont.DefaultWidth = new PdfNumeric(cidFont.DefaultWidth);
pdfCidFont.Widths = cidFont.WArray;
// Create a ToUnicode CMap that maps characters codes (GIDs) to
// unicode values. Very important to ensure searching and copying
// from a PDF document works correctly.
PdfCMap pdfCMap = new PdfCMap(NextObjectId());
pdfCMap.AddFilter(new FlateFilter());
pdfCMap.SystemInfo = pdfCidSystemInfo;
pdfCMap.AddBfRanges(cidFont.CMapEntries);
// Create a PDF object to represent the CID font
PdfType0Font pdfFont = new PdfType0Font(
NextObjectId(), pdfFontID, font.FontName);
pdfFont.Encoding = new PdfName(cidFont.Encoding);
pdfFont.Descendant = pdfCidFont;
pdfFont.ToUnicode = pdfCMap;
// Add all the Pdf objects to the document. MakeFont will add the actual
// PdfFont object to the document.
creator.AddObject(pdfDescriptor);
creator.AddObject(pdfCidFont);
creator.AddObject(pdfCMap);
creator.AddObject(fontFile);
return(pdfFont);
}
/// <summary>
/// Draw a string with the given font, inside a fixed rectangle with the given horizontal and vertical alignment inside that rectangle.
/// </summary>
/// <param name="text">The string to write.</param>
/// <param name="font">The font to use to draw. This must be y <see cref="FontDescriptor"/> object.</param>
/// <param name="rect">The bounding rectangle to draw the string in.</param>
/// <param name="hAlign">The horizontal alignment of the string within the bounding rectangle.</param>
/// <param name="vAlign">The vertical alignment of the string within the bounding rectangle.</param>
/// <exception cref="ArgumentException" />Thrown if the <see cref="IFontDescriptor" /> paramter is not a <see cref="FontDescriptor" /> object.
public void DrawString(string text, IFontDescriptor font, UniRectangle rect, HorizontalAlignment hAlign, VerticalAlignment vAlign)
{
if (!(font is FontDescriptor ourFont))
{
throw new ArgumentException(Resources.Error_FontDescriptorOfWrongSpecificType, nameof(font));
}
if (rect is null)
{
throw new ArgumentNullException(nameof(rect));
}
_core.DrawString(text, ourFont.Font, XBrushes.Black, new XRect(rect.Left, rect.Top, rect.Width, rect.Height), GetStringFormat(hAlign, vAlign));
}
/// <summary>
/// Constructor for cell with margins.
/// </summary>
/// <param name="content">The cell content.</param>
/// <param name="font">The font to use to draw the content.</param>
/// <param name="margins">The cell margins.</param>
/// <param name="graphicsContext">The graphics context which will be used to draw the cell.</param>
public PlainTextTableCell(string content, IFontDescriptor font, MarginSet margins, IGraphicsContext graphicsContext)
{
Content = content;
Font = font;
if (margins != null)
{
MarginLeft = margins.Left;
MarginRight = margins.Right;
MarginTop = margins.Top;
MarginBottom = margins.Bottom;
}
MeasureSize(graphicsContext);
}
/// <summary>
/// Add text to this paragraph.
/// </summary>
/// <param name="text">The text to be added.</param>
/// <param name="font">The font to be used to write the text.</param>
/// <param name="graphicsContext">The context to be used for metrics.</param>
public void AddText(string text, IFontDescriptor font, IGraphicsContext graphicsContext)
{
var words = Word.MakeWords(text, font, graphicsContext);
Lines.AddRange(Line.MakeLines(words, MaximumWidth - (Margins.Left + Margins.Right)));
if (Lines.Any(l => l.OverspillWidth))
{
OverspillWidth = true;
}
if (Lines.Sum(l => l.ContentHeight) > MaximumHeight)
{
OverspillHeight = true;
}
}
public void WordClass_MakeWordsMethod_ThrowsArgumentNullExceptionWithCorrectParamNameProperty_IfFirstParameterIsNotNullAndSecondParameterIsNull()
{
string testParam0 = _rnd.NextString(_rnd.Next(300));
IFontDescriptor testParam1 = null;
IGraphicsContext testParam2 = new Mock <IGraphicsContext>().Object;
try
{
_ = Word.MakeWords(testParam0, testParam1, testParam2).ToArray();
Assert.Fail();
}
catch (ArgumentNullException ex)
{
Assert.AreEqual("font", ex.ParamName);
}
}
private static Class40 smethod_4(string fontName, IFontMetric metrics)
{
IFontDescriptor descriptor = metrics.Descriptor;
Class40 class40 = new Class40(fontName);
class40.Ascent = metrics.Ascender;
class40.CapHeight = metrics.CapHeight;
class40.Descent = metrics.Descender;
class40.Flags = descriptor.Flags;
class40.ItalicAngle = descriptor.ItalicAngle;
class40.StemV = descriptor.StemV;
PdfArray pdfArray = new PdfArray();
pdfArray.AddRange((IEnumerable <int>)descriptor.FontBBox);
class40.FontBBox = pdfArray;
return(class40);
}
private PdfFontDescriptor MakeFontDescriptor(string fontName, IFontMetric metrics)
{
IFontDescriptor descriptor = metrics.Descriptor;
PdfFontDescriptor pdfDescriptor = new PdfFontDescriptor(
fontName, NextObjectId());
pdfDescriptor.Ascent = new PdfNumeric(metrics.Ascender);
pdfDescriptor.CapHeight = new PdfNumeric(metrics.CapHeight);
pdfDescriptor.Descent = new PdfNumeric(metrics.Descender);
pdfDescriptor.Flags = new PdfNumeric(descriptor.Flags);
pdfDescriptor.ItalicAngle = new PdfNumeric(descriptor.ItalicAngle);
pdfDescriptor.StemV = new PdfNumeric(descriptor.StemV);
PdfArray array = new PdfArray();
array.AddArray(descriptor.FontBBox);
pdfDescriptor.FontBBox = array;
return(pdfDescriptor);
}
/// <summary>
/// Construct a <see cref="Word" /> instance.
/// </summary>
/// <param name="content">The textual content of the word.</param>
/// <param name="font">The font to use for display.</param>
/// <param name="graphicsContext">The graphics context for providing metrics.</param>
/// <param name="postWordSpace">The minimum amount of space to add after the word if it is not at the end of a line.</param>
public Word(string content, IFontDescriptor font, IGraphicsContext graphicsContext, double postWordSpace)
{
if (font is null)
{
throw new ArgumentNullException(nameof(font));
}
Content = content;
Font = font;
PostWordSpace = postWordSpace;
if (string.IsNullOrEmpty(Content) || graphicsContext == null)
{
ContentWidth = 0;
ContentAscent = 0;
ContentDescent = 0;
}
else
{
var measure = graphicsContext.MeasureString(Content, Font);
ContentWidth = measure.Width;
ContentAscent = font.Ascent;
ContentDescent = measure.Height - ContentAscent;
}
}
/// <summary>
/// Convert a text string into zero or more <see cref="Word" /> instances by splitting it up on white space.
/// </summary>
/// <param name="text">The text to use to create the words.</param>
/// <param name="font">The font to display the text in.</param>
/// <param name="graphicsContext">The graphics context to use for rendering the words and providing metrics.</param>
/// <returns>An enumeration of <see cref="Word" /> instances, each consisting of a single word from the input text.</returns>
public static IEnumerable <Word> MakeWords(string text, IFontDescriptor font, IGraphicsContext graphicsContext)
{
if (text is null)
{
yield break;
}
if (font is null)
{
throw new ArgumentNullException(nameof(font));
}
double wordSpace = font.GetNormalSpaceWidth(graphicsContext);
string[] words = text.Split(null);
Log.Trace("Split text '{0}' into {1} words.", text, words.Length);
foreach (string word in words)
{
if (string.IsNullOrEmpty(word))
{
continue;
}
yield return(new Word(word, font, graphicsContext, wordSpace));
}
}
/// <summary>
/// Draw a string - dummy method
/// </summary>
/// <param name="text"></param>
/// <param name="font"></param>
/// <param name="rect"></param>
/// <param name="hAlign"></param>
/// <param name="vAlign"></param>
public void DrawString(string text, IFontDescriptor font, UniRectangle rect, HorizontalAlignment hAlign, VerticalAlignment vAlign)
{
}
/// <summary>
/// Constructor for cell with no margins.
/// </summary>
/// <param name="content">The cell content.</param>
/// <param name="font">The font to use to draw the content.</param>
/// <param name="graphicsContext">The graphics context which will be used to draw the cell.</param>
public PlainTextTableCell(string content, IFontDescriptor font, IGraphicsContext graphicsContext) : this(content, font, null, graphicsContext)
{
}
internal static PositionedLine ToPositionedLine(this FootnoteDisplayModel footnote, IGraphicsContext context, IFontDescriptor symbolFont, IFontDescriptor definitionFont)
{
Word symbolWord = new Word(footnote.Symbol, symbolFont, context, 5); // FIXME that very naked-looing "5" should definitely not be hard-coded.
List <Word> theWords = new List <Word> {
symbolWord
};
theWords.AddRange(Word.MakeWords(footnote.Definition, definitionFont, context));
return(new PositionedLine(theWords));
}
public static void PopulateSize(this TrainGraphAxisTickInfo tickInfo, IGraphicsContext context, IFontDescriptor font)
{
if (tickInfo is null)
{
throw new ArgumentNullException(nameof(tickInfo));
}
if (context is null)
{
throw new ArgumentNullException(nameof(context));
}
UniSize measure = context.MeasureString(tickInfo.Label, font);
tickInfo.Width = measure.Width;
tickInfo.Height = measure.Height;
}
/// <summary>
/// Draw a string - dummy method
/// </summary>
/// <param name="text"></param>
/// <param name="font"></param>
/// <param name="x"></param>
/// <param name="y"></param>
public void DrawString(string text, IFontDescriptor font, double x, double y)
{
}
/// <summary>
/// Measure a string - dummy method that returns a very rough approximation.
/// </summary>
/// <param name="text">The text to be measured</param>
/// <param name="font">The font in which the text is to be displayed</param>
/// <returns></returns>
public UniSize MeasureString(string text, IFontDescriptor font)
{
return(new UniSize((text ?? "").Length * 5, 7.2));
}
